BigfootDev/ConanPackages
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Initial commit

Browse Source
This commit is contained in:
Romain BOULLARD
2026-01-23 22:15:36 +01:00
commit ca60108606
167 changed files with 5311 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

231
sqlite3/all/CMakeLists.txt Normal file
View File

@@ -0,0 +1,231 @@
cmake_minimum_required(VERSION 3.15)
project(sqlite3 LANGUAGES C)
# Add some options from https://sqlite.org/compile.html
option(SQLITE3_BUILD_EXECUTABLE "Build sqlite command line utility for accessing SQLite databases")
option(ENABLE_JSON1 "Enable JSON SQL functions")
option(ENABLE_COLUMN_METADATA "Enable additional APIs that provide convenient access to meta-data about tables and queries")
option(ENABLE_DBSTAT_VTAB "Enable the DBSTAT virtual table")
option(ENABLE_EXPLAIN_COMMENTS "Enable SQLite to insert comment text into the output of EXPLAIN")
option(ENABLE_FTS3 "Enable version 3 of the full-text search engine")
option(ENABLE_FTS3_PARENTHESIS "Kodifies the query pattern parser in FTS3 such that it supports operators AND and NOT (in addition to the usual OR and NEAR) and also allows query expressions to contain nested parenthesis")
option(ENABLE_FTS4 "Enable version 3 and 4 of the full-text search engine")
option(ENABLE_FTS5 "Enable version 5 of the full-text search engine")
option(ENABLE_ICU "Enable support for the ICU extension")
option(ENABLE_MEMSYS5 "Enable MEMSYS5 memory allocator")
option(ENABLE_SOUNDEX "Enable the soundex() SQL function")
option(ENABLE_PREUPDATE_HOOK "Enables APIs to handle any change to a rowid table")
option(ENABLE_RTREE "Enable support for the R*Tree index extension")
option(ENABLE_UNLOCK_NOTIFY "Enable support for the unlock notify API")
option(ENABLE_DEFAULT_SECURE_DELETE "Turns on secure deletion by default")
option(USE_ALLOCA "The alloca() memory allocator will be used in a few situations where it is appropriate.")
option(USE_URI "This option causes the URI filename process logic to be enabled by default.")
option(OMIT_LOAD_EXTENSION "Omits the entire extension loading mechanism from SQLite")
option(OMIT_DEPRECATED "Omits deprecated interfaces and features")
if(SQLITE3_VERSION VERSION_GREATER_EQUAL "3.35.0")
option(ENABLE_MATH_FUNCTIONS "Enables the built-in SQL math functions" ON)
else()
set(ENABLE_MATH_FUNCTIONS OFF)
endif()
option(HAVE_FDATASYNC "Use fdatasync() instead of fsync() on unix systems")
option(HAVE_GMTIME_R "Use the threadsafe gmtime_r()")
option(HAVE_LOCALTIME_R "Use the threadsafe localtime_r()")
option(HAVE_POSIX_FALLOCATE "Use posix_fallocate()")
option(HAVE_STRERROR_R "Use strerror_r()")
option(HAVE_USLEEP "Use usleep() system call to implement the xSleep method")
option(DISABLE_GETHOSTUUID "Disable function gethostuuid")
set(MAX_COLUMN CACHE STRING "The maximum number of columns in a table / index / view")
set(MAX_VARIABLE_NUMBER CACHE STRING "The maximum value of a ?nnn wildcard that the parser will accept")
set(MAX_BLOB_SIZE CACHE STRING "Set the maximum number of bytes in a string or BLOB")
option(DISABLE_DEFAULT_VFS "Disable default VFS implementation")
option(ENABLE_DBPAGE_VTAB "The SQLITE_DBPAGE extension implements an eponymous-only virtual table that provides direct access to the underlying database file by interacting with the pager. SQLITE_DBPAGE is capable of both reading and writing any page of the database. Because interaction is through the pager layer, all changes are transactional.")
add_library(${PROJECT_NAME} ${SQLITE3_SRC_DIR}/sqlite3.c)
set_target_properties(${PROJECT_NAME} PROPERTIES C_VISIBILITY_PRESET hidden)
if(BUILD_SHARED_LIBS)
if(WIN32)
target_compile_definitions(${PROJECT_NAME}
PRIVATE "SQLITE_API=__declspec(dllexport)"
INTERFACE "SQLITE_API=__declspec(dllimport)"
)
else()
target_compile_definitions(${PROJECT_NAME}
PUBLIC "SQLITE_API=__attribute__((visibility(\"default\")))"
)
endif()
endif()
if(ENABLE_JSON1)
target_compile_definitions(${PROJECT_NAME} PRIVATE SQLITE_ENABLE_JSON1)
endif()
if(ENABLE_COLUMN_METADATA)
target_compile_definitions(${PROJECT_NAME} PRIVATE SQLITE_ENABLE_COLUMN_METADATA)
endif()
if(ENABLE_DBSTAT_VTAB)
target_compile_definitions(${PROJECT_NAME} PRIVATE SQLITE_ENABLE_DBSTAT_VTAB)
endif()
if(ENABLE_EXPLAIN_COMMENTS)
target_compile_definitions(${PROJECT_NAME} PRIVATE SQLITE_ENABLE_EXPLAIN_COMMENTS)
endif()
if(ENABLE_FTS3)
target_compile_definitions(${PROJECT_NAME} PRIVATE SQLITE_ENABLE_FTS3)
endif()
if(ENABLE_FTS3_PARENTHESIS)
target_compile_definitions(${PROJECT_NAME} PRIVATE SQLITE_ENABLE_FTS3_PARENTHESIS)
endif()
if(ENABLE_FTS4)
target_compile_definitions(${PROJECT_NAME} PRIVATE SQLITE_ENABLE_FTS4)
endif()
if(ENABLE_FTS5)
target_compile_definitions(${PROJECT_NAME} PRIVATE SQLITE_ENABLE_FTS5)
endif()
if(ENABLE_ICU)
target_compile_definitions(${PROJECT_NAME} PRIVATE SQLITE_ENABLE_ICU)
endif()
if(ENABLE_PREUPDATE_HOOK)
target_compile_definitions(${PROJECT_NAME} PRIVATE SQLITE_ENABLE_PREUPDATE_HOOK)
endif()
if(ENABLE_RTREE)
target_compile_definitions(${PROJECT_NAME} PRIVATE SQLITE_ENABLE_RTREE)
endif()
if(ENABLE_UNLOCK_NOTIFY)
target_compile_definitions(${PROJECT_NAME} PRIVATE SQLITE_ENABLE_UNLOCK_NOTIFY)
endif()
if(ENABLE_DEFAULT_SECURE_DELETE)
target_compile_definitions(${PROJECT_NAME} PRIVATE SQLITE_SECURE_DELETE)
endif()
if(ENABLE_MEMSYS5)
target_compile_definitions(${PROJECT_NAME} PRIVATE SQLITE_ENABLE_MEMSYS5)
endif()
if(ENABLE_SOUNDEX)
target_compile_definitions(${PROJECT_NAME} PRIVATE SQLITE_SOUNDEX)
endif()
if(USE_ALLOCA)
target_compile_definitions(${PROJECT_NAME} PRIVATE SQLITE_USE_ALLOCA)
endif()
if(USE_URI)
target_compile_definitions(${PROJECT_NAME} PRIVATE SQLITE_USE_URI)
endif()
if(OMIT_LOAD_EXTENSION)
target_compile_definitions(${PROJECT_NAME} PRIVATE SQLITE_OMIT_LOAD_EXTENSION)
endif()
if (OMIT_DEPRECATED)
target_compile_definitions(${PROJECT_NAME} PRIVATE SQLITE_OMIT_DEPRECATED)
endif()
if(ENABLE_MATH_FUNCTIONS)
target_compile_definitions(${PROJECT_NAME} PRIVATE SQLITE_ENABLE_MATH_FUNCTIONS)
endif()
if(HAVE_FDATASYNC)
target_compile_definitions(${PROJECT_NAME} PRIVATE HAVE_FDATASYNC)
endif()
if(HAVE_GMTIME_R)
target_compile_definitions(${PROJECT_NAME} PRIVATE HAVE_GMTIME_R)
endif()
if(HAVE_LOCALTIME_R)
target_compile_definitions(${PROJECT_NAME} PRIVATE HAVE_LOCALTIME_R)
endif()
if(HAVE_POSIX_FALLOCATE)
target_compile_definitions(${PROJECT_NAME} PRIVATE HAVE_POSIX_FALLOCATE)
endif()
if(HAVE_STRERROR_R)
target_compile_definitions(${PROJECT_NAME} PRIVATE HAVE_STRERROR_R)
endif()
if(HAVE_USLEEP)
target_compile_definitions(${PROJECT_NAME} PRIVATE HAVE_USLEEP)
endif()
if(DISABLE_GETHOSTUUID)
target_compile_definitions(${PROJECT_NAME} PRIVATE HAVE_GETHOSTUUID=0)
endif()
target_compile_definitions(${PROJECT_NAME} PRIVATE SQLITE_THREADSAFE=${THREADSAFE})
if(MAX_COLUMN)
target_compile_definitions(${PROJECT_NAME} PRIVATE SQLITE_MAX_COLUMN=${MAX_COLUMN})
endif()
if(MAX_VARIABLE_NUMBER)
target_compile_definitions(${PROJECT_NAME} PRIVATE SQLITE_MAX_VARIABLE_NUMBER=${MAX_VARIABLE_NUMBER})
endif()
if(MAX_BLOB_SIZE)
target_compile_definitions(${PROJECT_NAME} PRIVATE SQLITE_MAX_LENGTH=${MAX_BLOB_SIZE})
endif()
if(DISABLE_DEFAULT_VFS)
target_compile_definitions(${PROJECT_NAME} PRIVATE SQLITE_OS_OTHER=1)
endif()
if(ENABLE_DBPAGE_VTAB)
target_compile_definitions(${PROJECT_NAME} PRIVATE SQLITE_ENABLE_DBPAGE_VTAB)
endif()
if(THREADSAFE)
find_package(Threads REQUIRED)
target_link_libraries(${PROJECT_NAME} PRIVATE Threads::Threads)
endif()
if(ENABLE_ICU)
find_package(ICU REQUIRED COMPONENTS data i18n uc)
target_link_libraries(${PROJECT_NAME} PRIVATE ICU::i18n ICU::uc ICU::data)
enable_language(CXX) # required for linking language since ICU has c++ code
endif()
if(NOT OMIT_LOAD_EXTENSION)
target_link_libraries(${PROJECT_NAME} PRIVATE ${CMAKE_DL_LIBS})
endif()
set(SQLITE3_LIBRARY_NEEDS_MATH FALSE)
if(ENABLE_FTS5 OR ENABLE_MATH_FUNCTIONS)
set(SQLITE3_LIBRARY_NEEDS_MATH TRUE)
endif()
set(SQLITE3_EXECUTABLE_NEEDS_MATH FALSE)
if(SQLITE3_BUILD_EXECUTABLE AND SQLITE3_VERSION VERSION_GREATER_EQUAL "3.49.2")
set(SQLITE3_EXECUTABLE_NEEDS_MATH TRUE)
endif()
set(NEED_MATH_LIBRARY FALSE)
if(SQLITE3_LIBRARY_NEEDS_MATH OR SQLITE3_EXECUTABLE_NEEDS_MATH)
set(NEED_MATH_LIBRARY TRUE)
endif()
if(NEED_MATH_LIBRARY)
include(CheckLibraryExists)
# Check if math functionality is on the separate 'libm' library,
# otherwise assume that it is already part of the C runtime.
# The `m` library is part of the compiler toolchain, this checks
# if the compiler can successfully link against the library.
check_library_exists(m log "" HAVE_MATH_LIBRARY)
endif()
if(SQLITE3_LIBRARY_NEEDS_MATH AND HAVE_MATH_LIBRARY)
target_link_libraries(${PROJECT_NAME} PRIVATE m)
endif()
include(GNUInstallDirs)
install(TARGETS ${PROJECT_NAME}
RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR})
install(DIRECTORY ${SQLITE3_SRC_DIR}/ DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
FILES_MATCHING PATTERN "*.h")
if(SQLITE3_BUILD_EXECUTABLE)
add_executable(sqlite3-bin ${SQLITE3_SRC_DIR}/shell.c)
target_link_libraries(sqlite3-bin PRIVATE ${PROJECT_NAME})
if(SQLITE3_EXECUTABLE_NEEDS_MATH AND HAVE_MATH_LIBRARY)
target_link_libraries(sqlite3-bin PRIVATE m)
endif()
if(ENABLE_DBPAGE_VTAB)
target_compile_definitions(sqlite3-bin PRIVATE SQLITE_ENABLE_DBPAGE_VTAB)
endif()
if(ENABLE_ICU)
set_target_properties(sqlite3-bin PROPERTIES LINKER_LANGUAGE CXX)
endif()
if (MSVC)
# Prevent issue where an import library may be generated on Windows
# fatal error LNK1149: output filename matches input filename '\build\Release\sqlite3.lib'\
target_link_options(sqlite3-bin PRIVATE "/noimplib")
endif()
set_target_properties(sqlite3-bin PROPERTIES OUTPUT_NAME "sqlite3" PDB_NAME "sqlite3-bin")
include(CheckSymbolExists)
check_symbol_exists(system "stdlib.h" HAVE_SYSTEM)
if(NOT HAVE_SYSTEM)
target_compile_definitions(sqlite3-bin PRIVATE SQLITE_NOHAVE_SYSTEM)
endif()
install(TARGETS sqlite3-bin DESTINATION ${CMAKE_INSTALL_BINDIR})
endif()

21
sqlite3/all/cmake/SQLite3CLITargets.cmake Normal file
View File

@@ -0,0 +1,21 @@
if(NOT TARGET SQLite::SQLite3CLI)
if(CMAKE_CROSSCOMPILING)
find_program(SQLITE3_EXECUTABLE
NAMES sqlite3
PATHS ENV PATH
NO_DEFAULT_PATH
)
else()
find_program(SQLITE3_EXECUTABLE
NAMES sqlite3
PATHS "${CMAKE_CURRENT_LIST_DIR}/../../bin/"
NO_DEFAULT_PATH
)
endif()
if(SQLITE3_EXECUTABLE)
get_filename_component(SQLITE3_EXECUTABLE "${SQLITE3_EXECUTABLE}" ABSOLUTE)
add_executable(SQLite::SQLite3CLI IMPORTED)
set_property(TARGET SQLite::SQLite3CLI PROPERTY IMPORTED_LOCATION ${SQLITE3_EXECUTABLE})
endif()
endif()

16
sqlite3/all/conandata.yml Normal file
View File

@@ -0,0 +1,16 @@
sources:
"3.51.0":
url: "https://sqlite.org/2025/sqlite-amalgamation-3510000.zip"
sha256: "1caf7116f2910600d04473ad69d37ec538fa62fa36adccd37b5e0e43647c98be"
"3.50.4":
url: "https://sqlite.org/2025/sqlite-amalgamation-3500400.zip"
sha256: "1d3049dd0f830a025a53105fc79fd2ab9431aea99e137809d064d8ee8356b032"
"3.49.2":
url: "https://sqlite.org/2025/sqlite-amalgamation-3490200.zip"
sha256: "921fc725517a694df7df38a2a3dfede6684024b5788d9de464187c612afb5918"
"3.45.3":
url: "https://sqlite.org/2024/sqlite-amalgamation-3450300.zip"
sha256: "ea170e73e447703e8359308ca2e4366a3ae0c4304a8665896f068c736781c651"
"3.44.2":
url: "https://sqlite.org/2023/sqlite-amalgamation-3440200.zip"
sha256: "833be89b53b3be8b40a2e3d5fedb635080e3edb204957244f3d6987c2bb2345f"

214
sqlite3/all/conanfile.py Normal file
View File

@@ -0,0 +1,214 @@
from conan import ConanFile
from conan.errors import ConanInvalidConfiguration
from conan.tools.apple import is_apple_os
from conan.tools.cmake import CMake, CMakeToolchain, cmake_layout
from conan.tools.files import get, load, save, copy
import os
required_conan_version = ">=1.53.0"
class Sqlite3Conan(ConanFile):
name = "sqlite3"
description = "Self-contained, serverless, in-process SQL database engine."
license = "Unlicense"
url = "https://github.com/conan-io/conan-center-index"
homepage = "https://www.sqlite.org"
topics = ("sqlite", "database", "sql", "serverless")
package_type = "library"
settings = "os", "arch", "compiler", "build_type"
options = {
"shared": [True, False],
"fPIC": [True, False],
"threadsafe": [0, 1, 2],
"enable_column_metadata": [True, False],
"enable_dbstat_vtab": [True, False],
"enable_explain_comments": [True, False],
"enable_fts3": [True, False],
"enable_fts3_parenthesis": [True, False],
"enable_fts4": [True, False],
"enable_fts5": [True, False],
"enable_icu": [True, False],
"enable_json1": [True, False],
"enable_memsys5": [True, False],
"enable_soundex": [True, False],
"enable_preupdate_hook": [True, False],
"enable_rtree": [True, False],
"use_alloca": [True, False],
"use_uri": [True, False],
"omit_load_extension": [True, False],
"omit_deprecated": [True, False],
"enable_math_functions": [True, False],
"enable_unlock_notify": [True, False],
"enable_default_secure_delete": [True, False],
"disable_gethostuuid": [True, False],
"max_column": [None, "ANY"],
"max_variable_number": [None, "ANY"],
"max_blob_size": [None, "ANY"],
"build_executable": [True, False],
"enable_default_vfs": [True, False],
"enable_dbpage_vtab": [True, False],
}
default_options = {
"shared": False,
"fPIC": True,
"threadsafe": 1,
"enable_column_metadata": True,
"enable_dbstat_vtab": False,
"enable_explain_comments": False,
"enable_fts3": False,
"enable_fts3_parenthesis": False,
"enable_fts4": False,
"enable_fts5": False,
"enable_icu": False,
"enable_json1": False,
"enable_memsys5": False,
"enable_soundex": False,
"enable_preupdate_hook": False,
"enable_rtree": True,
"use_alloca": False,
"use_uri": False,
"omit_load_extension": False,
"omit_deprecated": False,
"enable_math_functions": True,
"enable_unlock_notify": True,
"enable_default_secure_delete": False,
"disable_gethostuuid": False,
"max_column": None, # Uses default value from source
"max_variable_number": None, # Uses default value from source
"max_blob_size": None, # Uses default value from source
"build_executable": True,
"enable_default_vfs": True,
"enable_dbpage_vtab": False,
}
exports_sources = "CMakeLists.txt"
def config_options(self):
if self.settings.os == "Windows":
del self.options.fPIC
def configure(self):
if self.options.shared:
self.options.rm_safe("fPIC")
self.settings.rm_safe("compiler.cppstd")
self.settings.rm_safe("compiler.libcxx")
def layout(self):
cmake_layout(self, src_folder="src")
def requirements(self):
if self.options.enable_icu:
self.requires("icu/75.1")
def validate(self):
if self.options.build_executable:
if not self.options.enable_default_vfs:
# Need to provide custom VFS code: https://www.sqlite.org/custombuild.html
raise ConanInvalidConfiguration("build_executable=True cannot be combined with enable_default_vfs=False")
if self.options.omit_load_extension:
raise ConanInvalidConfiguration("build_executable=True requires omit_load_extension=True")
def source(self):
get(self, **self.conan_data["sources"][self.version], strip_root=True)
def generate(self):
tc = CMakeToolchain(self)
tc.variables["SQLITE3_SRC_DIR"] = self.source_folder.replace("\\", "/")
tc.variables["SQLITE3_VERSION"] = self.version
tc.variables["SQLITE3_BUILD_EXECUTABLE"] = self.options.build_executable
tc.variables["THREADSAFE"] = self.options.threadsafe
tc.variables["ENABLE_COLUMN_METADATA"] = self.options.enable_column_metadata
tc.variables["ENABLE_DBSTAT_VTAB"] = self.options.enable_dbstat_vtab
tc.variables["ENABLE_EXPLAIN_COMMENTS"] = self.options.enable_explain_comments
tc.variables["ENABLE_FTS3"] = self.options.enable_fts3
tc.variables["ENABLE_FTS3_PARENTHESIS"] = self.options.enable_fts3_parenthesis
tc.variables["ENABLE_FTS4"] = self.options.enable_fts4
tc.variables["ENABLE_FTS5"] = self.options.enable_fts5
tc.variables["ENABLE_ICU"] = self.options.enable_icu
tc.variables["ENABLE_JSON1"] = self.options.enable_json1
tc.variables["ENABLE_MEMSYS5"] = self.options.enable_memsys5
tc.variables["ENABLE_PREUPDATE_HOOK"] = self.options.enable_preupdate_hook
tc.variables["ENABLE_SOUNDEX"] = self.options.enable_soundex
tc.variables["ENABLE_RTREE"] = self.options.enable_rtree
tc.variables["ENABLE_UNLOCK_NOTIFY"] = self.options.enable_unlock_notify
tc.variables["ENABLE_DEFAULT_SECURE_DELETE"] = self.options.enable_default_secure_delete
tc.variables["USE_ALLOCA"] = self.options.use_alloca
tc.variables["USE_URI"] = self.options.use_uri
tc.variables["OMIT_LOAD_EXTENSION"] = self.options.omit_load_extension
tc.variables["OMIT_DEPRECATED"] = self.options.omit_deprecated
tc.variables["ENABLE_MATH_FUNCTIONS"] = self.options.enable_math_functions
tc.variables["HAVE_FDATASYNC"] = True
tc.variables["HAVE_GMTIME_R"] = True
tc.variables["HAVE_LOCALTIME_R"] = self.settings.os != "Windows"
tc.variables["HAVE_POSIX_FALLOCATE"] = not (self.settings.os in ["Windows", "Android"] or is_apple_os(self))
tc.variables["HAVE_STRERROR_R"] = True
tc.variables["HAVE_USLEEP"] = True
tc.variables["DISABLE_GETHOSTUUID"] = self.options.disable_gethostuuid
if self.options.max_column:
tc.variables["MAX_COLUMN"] = self.options.max_column
if self.options.max_variable_number:
tc.variables["MAX_VARIABLE_NUMBER"] = self.options.max_variable_number
if self.options.max_blob_size:
tc.variables["MAX_BLOB_SIZE"] = self.options.max_blob_size
tc.variables["DISABLE_DEFAULT_VFS"] = not self.options.enable_default_vfs
tc.variables["ENABLE_DBPAGE_VTAB"] = self.options.enable_dbpage_vtab
tc.generate()
def build(self):
cmake = CMake(self)
cmake.configure(build_script_folder=os.path.join(self.source_folder, os.pardir))
cmake.build()
def _extract_license(self):
header = load(self, os.path.join(self.source_folder, "sqlite3.h"))
license_content = header[3:header.find("***", 1)]
return license_content
def package(self):
save(self, os.path.join(self.package_folder, "licenses", "LICENSE"), self._extract_license())
cmake = CMake(self)
cmake.install()
copy(self, "SQLite3CLITargets.cmake",
src=os.path.join(self.source_folder, os.pardir, "cmake"),
dst=os.path.join(self.package_folder, self._module_path))
def export_sources(self):
copy(self, os.path.join("cmake", "SQLite3CLITargets.cmake"), self.recipe_folder, self.export_sources_folder)
@property
def _module_path(self):
return os.path.join(self.package_folder, "lib", "cmake")
def package_info(self):
self.cpp_info.set_property("cmake_find_mode", "both")
self.cpp_info.set_property("cmake_file_name", "SQLite3")
self.cpp_info.set_property("cmake_target_name", "SQLite::SQLite3")
self.cpp_info.set_property("pkg_config_name", "sqlite3")
# TODO: back to global scope in conan v2 once cmake_find_package_* generators removed
self.cpp_info.components["sqlite"].libs = ["sqlite3"]
if self.options.enable_icu:
self.cpp_info.components["sqlite"].requires = ["icu::icu"]
if self.options.omit_load_extension:
self.cpp_info.components["sqlite"].defines.append("SQLITE_OMIT_LOAD_EXTENSION")
if self.settings.os in ["Linux", "FreeBSD"]:
if self.options.threadsafe:
self.cpp_info.components["sqlite"].system_libs.append("pthread")
if not self.options.omit_load_extension:
self.cpp_info.components["sqlite"].system_libs.append("dl")
if self.options.enable_fts5 or self.options.get_safe("enable_math_functions"):
self.cpp_info.components["sqlite"].system_libs.append("m")
elif self.settings.os == "Windows":
if self.options.shared:
self.cpp_info.components["sqlite"].defines.append("SQLITE_API=__declspec(dllimport)")
self.cpp_info.components["sqlite"].set_property("cmake_target_name", "SQLite::SQLite3")
self.cpp_info.components["sqlite"].set_property("pkg_config_name", "sqlite3")
if self.options.build_executable:
build_modules = [
os.path.join(self._module_path, "SQLite3CLITargets.cmake"),
]
self.cpp_info.set_property("cmake_build_modules", build_modules)

19
sqlite3/all/test_package/CMakeLists.txt Normal file
View File

@@ -0,0 +1,19 @@
cmake_minimum_required(VERSION 3.15)
project(test_package LANGUAGES C)
find_package(SQLite3 REQUIRED)
if(NOT SQLite3_INCLUDE_DIRS)
message(FATAL_ERROR "SQLite3_INCLUDE_DIRS CMake variable expected, but not defined")
endif()
if(NOT SQLite3_LIBRARIES)
message(FATAL_ERROR "SQLite3_LIBRARIES CMake variable expected, but not defined")
endif()
find_program(SQLITE3_EXECUTABLE NAMES sqlite3)
execute_process(COMMAND ${SQLITE3_EXECUTABLE} --version)
add_executable(${PROJECT_NAME} test_package.c)
target_link_libraries(${PROJECT_NAME} PRIVATE SQLite::SQLite3)

26
sqlite3/all/test_package/conanfile.py Normal file
View File

@@ -0,0 +1,26 @@
from conan import ConanFile
from conan.tools.build import can_run
from conan.tools.cmake import CMake, cmake_layout
import os
class TestPackageConan(ConanFile):
settings = "os", "arch", "compiler", "build_type"
generators = "CMakeToolchain", "CMakeDeps", "VirtualRunEnv"
test_type = "explicit"
def layout(self):
cmake_layout(self)
def requirements(self):
self.requires(self.tested_reference_str)
def build(self):
cmake = CMake(self)
cmake.configure()
cmake.build()
def test(self):
if can_run(self):
bin_path = os.path.join(self.cpp.build.bindirs[0], "test_package")
self.run(bin_path, env="conanrun")

7
sqlite3/all/test_package/test_package.c Normal file
View File

@@ -0,0 +1,7 @@
#include <stdio.h>
#include <sqlite3.h>
int main() {
printf("SQLite Version: %s\n", sqlite3_libversion());
return 0;
}