cmake/modules/FindSqlite.cmake

0001 # - Find SQLite 3
0002 # This module can be used to find SQLite 3.
0003 # (THIS IS AN EXTENDED VERSION OF THE FUTURE FindSqlite.cmake FOR KDB TO MAKE SURE
0004 #  THE DETECTION WORKS AS EXPECTED)
0005 #
0006 # Accepted variables:
0007 #  SQLITE_RECOMMENDED_VERSION
0008 #        If defined, warning will be displayed for SQLite versions older
0009 #        than specified.
0010 #        For example use this before calling find_package:
0011 #           set(SQLITE_RECOMMENDED_VERSION "3.6.22")
0012 #  SQLITE_LOAD_EXTENSION_REQUIRED
0013 #        If defined, extensions loading feature of SQLite is required.
0014 #        For example use this before calling find_package:
0015 #           set(SQLITE_LOAD_EXTENSION_REQUIRED ON)
0016 #
0017 # This module allows to depend on a particular minimum version of SQLite.
0018 # To acomplish that one should use the appropriate cmake syntax for
0019 # find_package(). For example to depend on SQLite >= 3.6.16 one should use:
0020 #
0021 #  find_package(SQLite 3.6.16 REQUIRED)
0022 #
0023 # Variables that FindSqlite.cmake sets:
0024 #  Sqlite_FOUND             TRUE if required version of Sqlite has been found
0025 #  SQLITE_INCLUDE_DIR       include directories to use SQLite
0026 #  SQLITE_LIBRARIES         link these to use SQLite
0027 #  SQLITE_MIN_VERSION       minimum version, if as the second argument of find_package()
0028 #  SQLITE_VERSION_STRING    found version of SQLite, e.g. "3.6.16"
0029 #  SQLITE_VERSION           integer for the found version of SQLite, e.g. 3006016 for 3.6.16
0030 #  SQLITE_MIN_VERSION_MAJOR found major version of SQLite, e.g. 3
0031 #  SQLITE_MIN_VERSION_MINOR found major version of SQLite, e.g. 6
0032 #  SQLITE_MIN_VERSION_PATCH found major version of SQLite, e.g. 16
0033 #  SQLITE_SHELL             sqlite3 executable with full path
0034 #  SQLITE_COMPILE_OPTIONS   compile options used to build libsqlite3
0035 #  SQLITE_CHECK_COMPILE_OPTION(X)
0036 #      Sets X variable to ON if option X has been set in compile options for libsqlite3.
0037 #      Supported can be, among others:
0038 #      ENABLE_COLUMN_METADATA ENABLE_FTS3 ENABLE_FTS3_PARENTHESIS ENABLE_MEMORY_MANAGEMENT
0039 #      ENABLE_RTREE ENABLE_UNLOCK_NOTIFY ENABLE_UPDATE_DELETE_LIMIT SECURE_DELETE SOUNDEX
0040 #      TEMP_STORE THREADSAFE OMIT_LOAD_EXTENSION.
0041 #      For complete list of options read https://www.sqlite.org/compile.html
0042 #      SQLITE_COMPILE_OPTIONS list is used for the check.
0043 #  SQLITE_INCLUDE_PATH      include directory for sqlite3.h
0044 #  SQLITE_EXT_INCLUDE_PATH      include directory for sqlite3ext.h
0045 #
0046 # Copyright (C) 2008 Gilles Caulier <caulier.gilles@gmail.com>
0047 # Copyright (C) 2010-2015 Jarosław Staniek <staniek@kde.org>
0048 #
0049 # Redistribution and use is allowed according to the terms of the BSD license.
0050 # For details see the accompanying COPYING-CMAKE-SCRIPTS file.
0051
0052 set(Sqlite_FOUND TRUE)
0053
0054 include(FeatureSummary)
0055 set_package_properties(Sqlite
0056     PROPERTIES DESCRIPTION "SQLite3 client library" URL "https://www.sqlite.org")
0057
0058 if(SQLITE_INCLUDE_DIR AND SQLITE_LIBRARIES)
0059    if(SQLITE_LOAD_EXTENSION_REQUIRED AND SQLITE_LOAD_EXTENSION OR NOT SQLITE_LOAD_EXTENSION_REQUIRED)
0060       # in cache already
0061       set(Sqlite_FIND_QUIETLY TRUE)
0062    endif()
0063 endif()
0064
0065 # use pkg-config to get the directories and then use these values
0066 # in the FIND_PATH() and FIND_LIBRARY() calls
0067 if(NOT WIN32)
0068   find_package(PkgConfig)
0069
0070   pkg_check_modules(PC_SQLITE QUIET sqlite3)
0071
0072   set(SQLITE_DEFINITIONS ${PC_SQLITE_CFLAGS_OTHER})
0073 endif()
0074
0075 set(SQLITE_INCLUDE_DIR) # start with empty list
0076
0077 find_path(SQLITE_INCLUDE_PATH NAMES sqlite3.h
0078   PATHS
0079   ${PC_SQLITE_INCLUDEDIR}
0080   ${PC_SQLITE_INCLUDE_DIRS}
0081 )
0082 if(SQLITE_INCLUDE_PATH)
0083   set(SQLITE_INCLUDE_DIR ${SQLITE_INCLUDE_DIR} ${SQLITE_INCLUDE_PATH})
0084 endif()
0085
0086 find_path(SQLITE_EXT_INCLUDE_PATH NAMES sqlite3ext.h
0087   PATHS
0088   ${PC_SQLITE_INCLUDEDIR}
0089   ${PC_SQLITE_INCLUDE_DIRS}
0090 )
0091 if(SQLITE_EXT_INCLUDE_PATH)
0092   set(SQLITE_INCLUDE_DIR ${SQLITE_INCLUDE_DIR} ${SQLITE_EXT_INCLUDE_PATH})
0093 endif()
0094
0095 # most of the headers will be in the same directories, avoid creating a list of duplicates
0096 if (SQLITE_INCLUDE_DIR)
0097   list(REMOVE_DUPLICATES SQLITE_INCLUDE_DIR)
0098 endif ()
0099
0100 find_library(SQLITE_LIBRARIES NAMES sqlite3
0101   PATHS
0102   ${PC_SQLITE_LIBDIR}
0103   ${PC_SQLITE_LIBRARY_DIRS}
0104 )
0105 #message(DEBUG " SQLITE_INCLUDE_DIR: ${SQLITE_INCLUDE_DIR}")
0106 #message(DEBUG " SQLITE_INCLUDE_PATH: ${SQLITE_INCLUDE_PATH}")
0107 #message(DEBUG " SQLITE_EXT_INCLUDE_PATH: ${SQLITE_EXT_INCLUDE_PATH}")
0108 #message(DEBUG " SQLITE_LIBRARIES: ${SQLITE_LIBRARIES}")
0109
0110 macro(_check_min_sqlite_version)
0111     # Suppport finding at least a particular version, for instance FIND_PACKAGE(Sqlite 3.6.22)
0112     if(Sqlite_FIND_VERSION)
0113         set(SQLITE_MIN_VERSION ${Sqlite_FIND_VERSION} CACHE STRING "Required SQLite minimal version" FORCE)
0114         set(SQLITE_MIN_VERSION_MAJOR ${Sqlite_FIND_VERSION_MAJOR} CACHE STRING "Required SQLite minimal version (major)" FORCE)
0115         set(SQLITE_MIN_VERSION_MINOR ${Sqlite_FIND_VERSION_MINOR} CACHE STRING "Required SQLite minimal version (minor)" FORCE)
0116         set(SQLITE_MIN_VERSION_PATCH ${Sqlite_FIND_VERSION_PATCH} CACHE STRING "Required SQLite minimal version (patch)" FORCE)
0117         math(EXPR SQLITE_MIN_VERSION_NUMBER
0118             "${SQLITE_MIN_VERSION_MAJOR} * 1000000 + ${SQLITE_MIN_VERSION_MINOR} * 1000 + ${SQLITE_MIN_VERSION_PATCH}")
0119         if(SQLITE_MIN_VERSION_NUMBER GREATER SQLITE_VERSION)
0120             if(Sqlite_FIND_REQUIRED)
0121                 message(FATAL_ERROR "Minimal SQLite version required: ${SQLITE_MIN_VERSION}, found ${SQLITE_VERSION_STRING}")
0122             else()
0123                 message(STATUS "WARNING: Minimal SQLite version required: ${SQLITE_MIN_VERSION}, found ${SQLITE_VERSION_STRING}")
0124             endif()
0125             unset(SQLITE_VERSION CACHE)
0126             set(Sqlite_FOUND FALSE)
0127         endif()
0128     endif()
0129
0130     if(Sqlite_FOUND)
0131         if(NOT Sqlite_FIND_QUIETLY)
0132             message(STATUS "Found SQLite version ${SQLITE_VERSION_STRING}")
0133         endif()
0134     endif()
0135 endmacro(_check_min_sqlite_version)
0136
0137 macro(_check_recommended_sqlite_version)
0138     if(SQLITE_RECOMMENDED_VERSION)
0139         string(REGEX REPLACE "([0-9]+)\\.([0-9]+)\\.([0-9]+)" "\\1" SQLITE_RECOMMENDED_VERSION_MAJOR ${SQLITE_RECOMMENDED_VERSION})
0140         string(REGEX REPLACE "([0-9]+)\\.([0-9]+)\\.([0-9]+)" "\\2" SQLITE_RECOMMENDED_VERSION_MINOR ${SQLITE_RECOMMENDED_VERSION})
0141         string(REGEX REPLACE "([0-9]+)\\.([0-9]+)\\.([0-9]+)" "\\3" SQLITE_RECOMMENDED_VERSION_PATCH ${SQLITE_RECOMMENDED_VERSION})
0142         math(EXPR SQLITE_RECOMMENDED_VERSION_NUMBER
0143             "${SQLITE_RECOMMENDED_VERSION_MAJOR} * 1000000 + ${SQLITE_RECOMMENDED_VERSION_MINOR} * 1000 + ${SQLITE_RECOMMENDED_VERSION_PATCH}")
0144         if(SQLITE_RECOMMENDED_VERSION_NUMBER GREATER SQLITE_VERSION)
0145             message(STATUS "NOTE: Recommended SQLite version is ${SQLITE_RECOMMENDED_VERSION} (but ${SQLITE_VERSION_STRING} is still OK)")
0146         endif()
0147     endif()
0148 endmacro(_check_recommended_sqlite_version)
0149
0150 macro(_get_compile_options)
0151     find_program(SQLITE_SHELL sqlite3 DOC "sqlite3 executable with full path")
0152     if (SQLITE_SHELL)
0153         set(_COMPILE_OPTIONS_TEST_DB pragma_compile_options_test.sqlite3)
0154         execute_process(COMMAND ${SQLITE_SHELL} ${_COMPILE_OPTIONS_TEST_DB} "pragma compile_options"
0155                         OUTPUT_VARIABLE _COMPILE_OPTIONS_RESULT)
0156         string(REGEX REPLACE "=1\n" ";" SQLITE_COMPILE_OPTIONS "${_COMPILE_OPTIONS_RESULT}")
0157         string(REPLACE "\n" ";" SQLITE_COMPILE_OPTIONS "${SQLITE_COMPILE_OPTIONS}")
0158         set(SQLITE_COMPILE_OPTIONS ${SQLITE_COMPILE_OPTIONS})
0159     endif ()
0160 endmacro(_get_compile_options)
0161
0162 macro(SQLITE_CHECK_COMPILE_OPTION _OPTION_NAME)
0163     list(FIND SQLITE_COMPILE_OPTIONS "${_OPTION_NAME}" _RESULT)
0164     if (NOT ${_RESULT} EQUAL -1)
0165         set(${_OPTION_NAME} ON)
0166     endif ()
0167 endmacro(SQLITE_CHECK_COMPILE_OPTION)
0168
0169 if(NOT EXISTS "${SQLITE_INCLUDE_DIR}/sqlite3.h")
0170     set(Sqlite_FOUND FALSE)
0171 endif()
0172
0173 if(Sqlite_FOUND)
0174    file(READ "${SQLITE_INCLUDE_DIR}/sqlite3.h" SQLITE_VERSION_CONTENT)
0175    string(REGEX MATCH "#define SQLITE_VERSION[ ]+\"[0-9]+\\.[0-9]+\\.[0-9]+\"" SQLITE_VERSION_STRING_MATCH ${SQLITE_VERSION_CONTENT})
0176    if(NOT SQLITE_VERSION_STRING_MATCH)
0177       string(REGEX MATCH "#define SQLITE_VERSION[ ]+\"[0-9]+\\.[0-9]+\\.[0-9]+\\.[0-9]+\"" SQLITE_VERSION_STRING_MATCH ${SQLITE_VERSION_CONTENT})
0178    endif()
0179    string(REGEX MATCH "#define SQLITE_VERSION_NUMBER[ ]*[0-9]*\n" SQLITE_VERSION_MATCH ${SQLITE_VERSION_CONTENT})
0180    if(SQLITE_VERSION_STRING_MATCH AND SQLITE_VERSION_MATCH)
0181       string(REGEX REPLACE "#define SQLITE_VERSION[ ]*\"(.*)\".*" "\\1" SQLITE_VERSION_STRING ${SQLITE_VERSION_STRING_MATCH})
0182       string(REGEX REPLACE "#define SQLITE_VERSION_NUMBER[ ]*([0-9]*)\n" "\\1" SQLITE_VERSION ${SQLITE_VERSION_MATCH})
0183       set(SQLITE_VERSION ${SQLITE_VERSION} CACHE STRING "SQLite numeric version")
0184       set(SQLITE_VERSION_STRING ${SQLITE_VERSION_STRING} CACHE STRING "SQLite version")
0185       _check_min_sqlite_version()
0186    else()
0187        set(Sqlite_FOUND FALSE)
0188    endif()
0189    if(Sqlite_FOUND)
0190        _check_recommended_sqlite_version()
0191        _get_compile_options()
0192        if(SQLITE_LOAD_EXTENSION_REQUIRED)
0193           sqlite_check_compile_option(OMIT_LOAD_EXTENSION)
0194           if(OMIT_LOAD_EXTENSION)
0195               message(STATUS "WARNING: SQLite found but it is not built with support for extensions loading. It should be configured with --enable-load-extension option.")
0196               set(Sqlite_FOUND FALSE)
0197           else()
0198               set(SQLITE_LOAD_EXTENSION ON CACHE STRING "Support for extensions loading in SQLite")
0199               if(NOT Sqlite_FIND_QUIETLY)
0200                   message(STATUS "Found support for extensions loading in SQLite.")
0201               endif()
0202           endif()
0203       endif()
0204    endif()
0205 endif()
0206
0207 include(FindPackageHandleStandardArgs)
0208 find_package_handle_standard_args(Sqlite
0209                                   REQUIRED_VARS SQLITE_INCLUDE_DIR SQLITE_LIBRARIES SQLITE_MIN_VERSION
0210                                                 SQLITE_VERSION_STRING SQLITE_VERSION
0211                                                 SQLITE_MIN_VERSION_MAJOR SQLITE_MIN_VERSION_MINOR
0212                                                 SQLITE_MIN_VERSION_PATCH
0213 )
0214
0215 if(Sqlite_FOUND)
0216    set(Sqlite_FOUND 1 CACHE INTERNAL "" FORCE)
0217 else()
0218    unset(Sqlite_FOUND CACHE)
0219    set(Sqlite_FOUND FALSE)
0220    unset(SQLITE_INCLUDE_DIR)
0221    unset(SQLITE_INCLUDE_DIR CACHE)
0222    unset(SQLITE_LIBRARIES)
0223    unset(SQLITE_LIBRARIES CACHE)
0224    unset(SQLITE_VERSION)
0225    unset(SQLITE_VERSION CACHE)
0226    unset(SQLITE_VERSION_STRING)
0227    unset(SQLITE_VERSION_STRING CACHE)
0228    unset(SQLITE_LOAD_EXTENSION)
0229    unset(SQLITE_LOAD_EXTENSION CACHE)
0230    unset(Sqlite_EXT_INCLUDE_PATH)
0231 endif()
0232
0233 mark_as_advanced(SQLITE_INCLUDE_DIR SQLITE_LIBRARIES SQLITE_SHELL)