chore: Assets 디렉토리 구조 정리 및 네이밍 컨벤션 적용

- Assets/_Game/ 하위로 게임 에셋 통합
- External/ 패키지 벤더별 분류 (Synty, Animations, UI)
- 에셋 네이밍 컨벤션 확립 및 적용
  (Data_Skill_, Data_SkillEffect_, Prefab_, Anim_, Model_, BT_ 등)
- pre-commit hook으로 네이밍 컨벤션 자동 검사 추가
- RESTRUCTURE_CHECKLIST.md 작성

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
This commit is contained in:
2026-03-16 19:08:27 +09:00
parent 309bf5f48b
commit c265f980db
17251 changed files with 2630777 additions and 206 deletions

View File

@@ -0,0 +1,77 @@
# Changelog
## [Unreleased](https://github.com/gilzoide/unity-sqlite-net/compare/1.2.4...HEAD)
## [1.2.4](https://github.com/gilzoide/unity-sqlite-net/tree/1.2.4)
### Fixed
- Crash when used in the Unity Editor in Linux platform
## [1.2.3](https://github.com/gilzoide/unity-sqlite-net/tree/1.2.3)
### Fixed
- Support for Android 15 devices using 16KB memory page size (reference: https://developer.android.com/guide/practices/page-sizes)
## [1.2.2](https://github.com/gilzoide/unity-sqlite-net/tree/1.2.2)
### Changed
- Updated SQLite to 3.49.0
- Compile SQLite from source in WebGL platform
### Fixed
- Support for WebGL builds with any native build configuration
- Make all column-related attributes inherit Unity's `PreserveAttribute`, avoiding properties being stripped from builds
## [1.2.1](https://github.com/gilzoide/unity-sqlite-net/tree/1.2.1)
### Added
- Add support for updating a struct passed to `Insert` with overload accepting `ref T`
### Fixed
- Support for struct return types in queries
## [1.2.0](https://github.com/gilzoide/unity-sqlite-net/tree/1.2.0)
### Added
- GitHub Action that builds all native libraries
- Support for macOS with Intel CPU
### Changed
- Updated SQLite to 3.48.0
- Updated SQLite-net to v1.9.172
## [1.1.2](https://github.com/gilzoide/unity-sqlite-net/tree/1.1.2)
### Fixed
- Support for the async API in WebGL platform
## [1.1.1](https://github.com/gilzoide/unity-sqlite-net/tree/1.1.1)
### Fixed
- "duplicate column name" errors on `CreateTable` on builds with managed code stripping enabled
## [1.1.0](https://github.com/gilzoide/unity-sqlite-net/tree/1.1.0)
### Added
- Support for persisting data in WebGL builds using idbvfs
- SQLiteREPL sample
- SQLitePreparedStatement class, a low-level wrapper for `sqlite3_stmt`
- Support for code signing macOS shared library from Makefile
### Changed
- Updated SQLite to 3.46.1
- Change version of Emscripten used from latest to 1.40.1, so that the plugin works in Unity versions below 2021.2
### Fixed
- Remove usage of `--platform` on Dockerfile to work with newer versions of Docker
## [1.0.1](https://github.com/gilzoide/unity-sqlite-net/tree/1.0.1)
### Changed
- License first-party code under the MIT license
## [1.0.0](https://github.com/gilzoide/unity-sqlite-net/tree/1.0.0)
### Added
- SQLite 3.45.2, prebuilt for Windows, Linux, macOS, Android and WebGL, and built from source in iOS, tvOS and visionOS
- SQLite-net v1.8.116, both sync and async APIs
- `SQLiteConnection.Serialize` and `SQLiteConnection.Deserialize` extension methods

View File

@@ -0,0 +1,7 @@
fileFormatVersion: 2
guid: 923514db601094436a73902b0d903f44
TextScriptImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

View File

@@ -0,0 +1,19 @@
Copyright (c) 2024 Gil Barbosa Reis
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

View File

@@ -0,0 +1,7 @@
fileFormatVersion: 2
guid: 81cfe1728e89140d2b3246a08a7eeb6d
DefaultImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

View File

@@ -0,0 +1,8 @@
fileFormatVersion: 2
guid: 59d6228b57ea44c22bf2acc6f71ce64c
folderAsset: yes
DefaultImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

View File

@@ -0,0 +1,140 @@
# Android setup
ANDROID_NDK_ROOT ?=
# macOS code signing setup
CODESIGN ?= codesign
MACOS_CODESIGN_SIGNATURE ?=
# Download GitHub Action releases
GITHUB_CLI_BIN ?= gh
GITHUB_REPO ?= gilzoide/unity-sqlite-net
RUN_ID ?=
ifeq ($(DEBUG),1)
CFLAGS += -O0 -g -DDEBUG
else
CFLAGS += -O3 -DNDEBUG
endif
BUILD_DIRS = \
lib/windows/x86_64 lib/windows/x86 lib/windows/arm64 \
lib/linux/x86_64 lib/linux/x86 \
lib/macos \
lib/android/arm64 lib/android/arm32 lib/android/x86 lib/android/x86_64
SQLITE_SRC = sqlite-amalgamation/sqlite3.c
SQLITE_NET_SRC = $(wildcard sqlite-net~/src/*.cs) sqlite-net~/LICENSE.txt
SQLITE_NET_DEST = ../Runtime/sqlite-net
SQLITE_NET_SED_SCRIPT = tools~/fix-library-path.sed
$(BUILD_DIRS):
mkdir -p $@
.PRECIOUS: lib/%/sqlite3.o~
lib/%/sqlite3.o~: $(SQLITE_SRC) | lib/%
$(CC) -c -o $@ $< $(CFLAGS)
# Windows
lib/windows/%/gilzoide-sqlite-net.dll: LINKFLAGS += -shared
lib/windows/%/gilzoide-sqlite-net.dll: lib/windows/%/sqlite3.o~ | lib/windows/%
$(CC) -o $@ $^ $(LINKFLAGS)
# Linux
lib/linux/%/libgilzoide-sqlite-net.so: CFLAGS += -fPIC
# Note: The "-Wl,-Bsymbolic" flags prevent the dynamic linker from interposing the plugins calls to its
# own exported symbols with identically-named symbols in other loaded libraries (like /usr/lib/libsqlite3.so.0)
# which can cause a Unity Editor crash otherwise.
lib/linux/%/libgilzoide-sqlite-net.so: LINKFLAGS += -shared -lm -Wl,-Bsymbolic
lib/linux/%/libgilzoide-sqlite-net.so: lib/linux/%/sqlite3.o~ | lib/linux/%
$(CC) -o $@ $^ $(LINKFLAGS)
# macOS
lib/macos/libgilzoide-sqlite-net.dylib: CFLAGS += -arch arm64 -arch x86_64 -isysroot $(shell xcrun --show-sdk-path --sdk macosx)
lib/macos/libgilzoide-sqlite-net.dylib: LINKFLAGS += -shared -arch arm64 -arch x86_64
lib/macos/libgilzoide-sqlite-net.dylib: lib/macos/sqlite3.o~ | lib/macos
$(CC) -o $@ $^ $(LINKFLAGS)
ifdef MACOS_CODESIGN_SIGNATURE
$(CODESIGN) -s "$(MACOS_CODESIGN_SIGNATURE)" $@
endif
# Android
check-ndk-root:
ifndef ANDROID_NDK_ROOT
$(error ANDROID_NDK_ROOT must be set for Android builds!)
endif
lib/android/%/libgilzoide-sqlite-net.so: CFLAGS += -fPIC
lib/android/%/libgilzoide-sqlite-net.so: LINKFLAGS += -shared -lm -Wl,-z,max-page-size=16384
lib/android/%/libgilzoide-sqlite-net.so: lib/android/%/sqlite3.o~ check-ndk-root | lib/android/%
$(CC) -o $@ $< $(LINKFLAGS)
lib/android/arm64/libgilzoide-sqlite-net.so: CC = $(wildcard $(ANDROID_NDK_ROOT)/toolchains/llvm/prebuilt/*/bin/aarch64-linux-android21-clang)
lib/android/arm32/libgilzoide-sqlite-net.so: CC = $(wildcard $(ANDROID_NDK_ROOT)/toolchains/llvm/prebuilt/*/bin/armv7a-linux-androideabi21-clang)
lib/android/x86_64/libgilzoide-sqlite-net.so: CC = $(wildcard $(ANDROID_NDK_ROOT)/toolchains/llvm/prebuilt/*/bin/x86_64-linux-android21-clang)
lib/android/x86/libgilzoide-sqlite-net.so: CC = $(wildcard $(ANDROID_NDK_ROOT)/toolchains/llvm/prebuilt/*/bin/i686-linux-android21-clang)
# Source
$(SQLITE_NET_DEST)/%.cs: sqlite-net~/src/%.cs $(SQLITE_NET_SED_SCRIPT)
cat $< | sed -E -f $(SQLITE_NET_SED_SCRIPT) > $@
$(SQLITE_NET_DEST)/License.txt: sqlite-net~/License.txt
cp $< $@
# Targets
windows-x86_64: lib/windows/x86_64/gilzoide-sqlite-net.dll
windows-x86: lib/windows/x86/gilzoide-sqlite-net.dll
windows-arm64: lib/windows/arm64/gilzoide-sqlite-net.dll
windows-mingw-x86_64: CC = x86_64-w64-mingw32-gcc
windows-mingw-x86_64: LINKFLAGS += -static-libgcc
windows-mingw-x86_64: lib/windows/x86_64/gilzoide-sqlite-net.dll
windows-mingw-x86: CC = i686-w64-mingw32-gcc
windows-mingw-x86: LINKFLAGS += -static-libgcc
windows-mingw-x86: lib/windows/x86/gilzoide-sqlite-net.dll
windows-mingw-arm64: CC = aarch64-w64-mingw32-gcc
windows-mingw-arm64: LINKFLAGS += -static-libgcc
windows-mingw-arm64: lib/windows/arm64/gilzoide-sqlite-net.dll
linux-x86_64: lib/linux/x86_64/libgilzoide-sqlite-net.so
macos-universal: lib/macos/libgilzoide-sqlite-net.dylib
android-arm64: lib/android/arm64/libgilzoide-sqlite-net.so
android-arm32: lib/android/arm32/libgilzoide-sqlite-net.so
android-x86_64: lib/android/x86_64/libgilzoide-sqlite-net.so
android-x86: lib/android/x86/libgilzoide-sqlite-net.so
source: $(SQLITE_NET_DEST)/License.txt $(SQLITE_NET_DEST)/AssemblyInfo.cs $(SQLITE_NET_DEST)/SQLite.cs $(SQLITE_NET_DEST)/SQLiteAsync.cs
all-android: android-arm64 android-arm32 android-x86_64 android-x86
all-apple: macos-universal
all-linux: linux-x86_64
all-windows: windows-x86_64 windows-x86
all-windows-mingw: windows-mingw-x86_64 windows-mingw-x86
all-windows-llvm-mingw: windows-mingw-x86_64 windows-mingw-x86 windows-mingw-arm64
# Dockerized builds
docker-all-android:
docker build -f tools~/Dockerfile.build.android --platform=linux/amd64 -t gilzoide-sqlite-net-build-android:latest $(DOCKER_BUILD_ARGS) .
docker run --rm -v "$(CURDIR)":/src -w /src --platform=linux/amd64 gilzoide-sqlite-net-build-android:latest make all-android
docker-all-linux:
docker build -f tools~/Dockerfile.build.linux --platform=linux/amd64 -t gilzoide-sqlite-net-build-linux:latest $(DOCKER_BUILD_ARGS) .
docker run --rm -v "$(CURDIR)":/src -w /src --platform=linux/amd64 gilzoide-sqlite-net-build-linux:latest make all-linux
docker-all-windows:
docker build -f tools~/Dockerfile.build.windows -t gilzoide-sqlite-net-build-windows:latest $(DOCKER_BUILD_ARGS) .
docker run --rm -v "$(CURDIR)":/src -w /src gilzoide-sqlite-net-build-windows:latest make all-windows-mingw
docker-all-windows-llvm:
docker run --rm -v "$(CURDIR)":/src -w /src mstorsjo/llvm-mingw:latest make all-windows-llvm-mingw
# Download builds from GitHub Actions
download-latest-build:
$(eval TMPDIR := $(shell mktemp -d))
$(GITHUB_CLI_BIN) run download $(RUN_ID) --repo $(GITHUB_REPO) -p gilzoide-sqlite-net-* -D $(TMPDIR)
rsync -r $(TMPDIR)/gilzoide-sqlite-net-windows/* lib/windows/
rsync -r $(TMPDIR)/gilzoide-sqlite-net-linux/* lib/linux/
rsync -r $(TMPDIR)/gilzoide-sqlite-net-android/* lib/android/
rsync -r $(TMPDIR)/gilzoide-sqlite-net-macos/* lib/macos/
$(RM) -r $(TMPDIR)

View File

@@ -0,0 +1,7 @@
fileFormatVersion: 2
guid: d937f0ae4113443b78db34d7d15cd41b
DefaultImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

View File

@@ -0,0 +1,8 @@
fileFormatVersion: 2
guid: 346c87c5708c44a7bbc2987f97045ee8
folderAsset: yes
DefaultImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

View File

@@ -0,0 +1,594 @@
/**
* @file SQLiteVfs.hpp
* Single header with classes for easily implementing SQLite VFS shims in C++11
*
* How to use it:
* ```cpp
* #include <iostream>
* #include <SQLiteVfs.hpp>
*
* // 1. Implement your File shim, override any methods you want
* struct MySQLiteFile : SQLiteFileImpl {
* int xRead(void *p, int iAmt, sqlite3_int64 iOfst) override {
* std::cout << "READING" << std::endl;
* return SQLiteFileImpl::xRead(p, iAmt, iOfst);
* }
* }
*
* // 2. Implement your VFS shim, override any methods you want
* struct MySQLiteVfs : SQLiteVfsImpl<MySQLiteFile> {
* int xOpen(sqlite3_filename zName, SQLiteFile<TFileImpl> *file, int flags, int *pOutFlags) override {
* std::cout << "OPENING FILE " << zName << std::endl;
* return SQLiteVfsImpl::xOpen(zName, file, flags, pOutFlags);
* }
* }
*
* // 3. Register your VFS
* static MySQLiteVfs my_vfs("myvfs");
* int register_my_vfs() {
* return my_vfs.register_vfs(false);
* }
*
* // 4. (optional) Unregister your VFS
* void unregister_my_vfs() {
* my_vfs.unregister_vfs();
* }
* ```
*/
/*
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
*
* For more information, please refer to <http://unlicense.org/>
*/
#ifndef __SQLITE_VFS_HPP__
#define __SQLITE_VFS_HPP__
#include <new>
#include "../sqlite-amalgamation/sqlite3.h"
namespace sqlitevfs {
/**
* SQLite File implementation with virtual methods for C++.
*
* The default method implementations forward execution to `original_file`.
*
* You should not create objects of this type manually.
* Instead, you should subclass it, overriding any of the methods necessary, and pass your subclass to `SQLiteVfsImpl<>`.
*
* @note Destructors will be called automatically by `SQLiteFile` right after `xClose` is called.
*
* @see https://sqlite.org/c3ref/file.html
*/
struct SQLiteFileImpl {
/**
* File used by the default method implementations.
*/
sqlite3_file *original_file;
/**
* Determine which functions are supported by this implementation.
*
* The default implementation returns `original_file`'s `iVersion`, or 1 if it is NULL.
* Override this to report a different version.
* @see https://sqlite.org/c3ref/io_methods.html
*/
virtual int iVersion() const {
return original_file ? original_file->pMethods->iVersion : 1;
}
/// @see https://sqlite.org/c3ref/io_methods.html
virtual int xClose() {
return original_file->pMethods->xClose(original_file);
}
/// @see https://sqlite.org/c3ref/io_methods.html
virtual int xRead(void *p, int iAmt, sqlite3_int64 iOfst) {
return original_file->pMethods->xRead(original_file, p, iAmt, iOfst);
}
/// @see https://sqlite.org/c3ref/io_methods.html
virtual int xWrite(const void *p, int iAmt, sqlite3_int64 iOfst) {
return original_file->pMethods->xWrite(original_file, p, iAmt, iOfst);
}
/// @see https://sqlite.org/c3ref/io_methods.html
virtual int xTruncate(sqlite3_int64 size) {
return original_file->pMethods->xTruncate(original_file, size);
}
/// @see https://sqlite.org/c3ref/io_methods.html
virtual int xSync(int flags) {
return original_file->pMethods->xSync(original_file, flags);
}
/// @see https://sqlite.org/c3ref/io_methods.html
virtual int xFileSize(sqlite3_int64 *pSize) {
return original_file->pMethods->xFileSize(original_file, pSize);
}
/// @see https://sqlite.org/c3ref/io_methods.html
virtual int xLock(int flags) {
return original_file->pMethods->xLock(original_file, flags);
}
/// @see https://sqlite.org/c3ref/io_methods.html
virtual int xUnlock(int flags) {
return original_file->pMethods->xUnlock(original_file, flags);
}
/// @see https://sqlite.org/c3ref/io_methods.html
virtual int xCheckReservedLock(int *pResOut) {
return original_file->pMethods->xCheckReservedLock(original_file, pResOut);
}
/// @see https://sqlite.org/c3ref/io_methods.html
virtual int xFileControl(int op, void *pArg) {
return original_file->pMethods->xFileControl(original_file, op, pArg);
}
/// @see https://sqlite.org/c3ref/io_methods.html
virtual int xSectorSize() {
return original_file->pMethods->xSectorSize(original_file);
}
/// @see https://sqlite.org/c3ref/io_methods.html
virtual int xDeviceCharacteristics() {
return original_file->pMethods->xDeviceCharacteristics(original_file);
}
/* Methods above are valid for version 1 */
/// @see https://sqlite.org/c3ref/io_methods.html
virtual int xShmMap(int iPg, int pgsz, int flags, void volatile**pp) {
return original_file->pMethods->xShmMap(original_file, iPg, pgsz, flags, pp);
}
/// @see https://sqlite.org/c3ref/io_methods.html
virtual int xShmLock(int offset, int n, int flags) {
return original_file->pMethods->xShmLock(original_file, offset, n, flags);
}
/// @see https://sqlite.org/c3ref/io_methods.html
virtual void xShmBarrier() {
return original_file->pMethods->xShmBarrier(original_file);
}
/// @see https://sqlite.org/c3ref/io_methods.html
virtual int xShmUnmap(int deleteFlag) {
return original_file->pMethods->xShmUnmap(original_file, deleteFlag);
}
/* Methods above are valid for version 2 */
/// @see https://sqlite.org/c3ref/io_methods.html
virtual int xFetch(sqlite3_int64 iOfst, int iAmt, void **pp) {
return original_file->pMethods->xFetch(original_file, iOfst, iAmt, pp);
}
/// @see https://sqlite.org/c3ref/io_methods.html
virtual int xUnfetch(sqlite3_int64 iOfst, void *p) {
return original_file->pMethods->xUnfetch(original_file, iOfst, p);
}
/* Methods above are valid for version 3 */
/* Additional methods may be added in future releases */
};
/**
* POD `sqlite3_file` subclass that forwards all invocations to an embedded object that inherits `SQLiteFileImpl`.
*
* You should not create objects of this type manually nor subclass it.
*
* @tparam TFileImpl `SQLiteFileImpl` subclass
*/
template<typename TFileImpl>
struct SQLiteFile : public sqlite3_file {
using FileImpl = TFileImpl;
/**
* SQLite IO methods populated by `SQLiteFile::setup`.
*/
sqlite3_io_methods methods;
/**
* File implementation object of the `SQLiteFileImpl` subclass passed as template parameter to `SQLiteVfsImpl<>`.
*/
FileImpl implementation;
sqlite3_file original_file[0];
/**
* Setup internal state based on the `open_result` flag.
*
* This function is called automatically by `SQLiteVfs::wrap_xOpen`.
* If `open_result` is `SQLITE_OK`, `pMethods` will be populated.
* Otherwise, `pMethods` will be set to NULL and SQLite won't call them.
*
* @param open_result A SQLite error code. Pass `SQLITE_OK` to fully setup the file object.
* Pass anything else to set `pMethods` to NULL.
*/
void setup(int open_result) {
if (open_result == SQLITE_OK) {
implementation.original_file = original_file;
methods = {
implementation.iVersion(),
&wrap_xClose,
&wrap_xRead,
&wrap_xWrite,
&wrap_xTruncate,
&wrap_xSync,
&wrap_xFileSize,
&wrap_xLock,
&wrap_xUnlock,
&wrap_xCheckReservedLock,
&wrap_xFileControl,
&wrap_xSectorSize,
&wrap_xDeviceCharacteristics,
&wrap_xShmMap,
&wrap_xShmLock,
&wrap_xShmBarrier,
&wrap_xShmUnmap,
&wrap_xFetch,
&wrap_xUnfetch,
};
pMethods = &methods;
}
else {
pMethods = nullptr;
}
}
private:
static int wrap_xClose(sqlite3_file *file) {
int result = static_cast<SQLiteFile *>(file)->implementation.xClose();
static_cast<SQLiteFile *>(file)->~SQLiteFile();
return result;
}
static int wrap_xRead(sqlite3_file *file, void *p, int iAmt, sqlite3_int64 iOfst) {
return static_cast<SQLiteFile *>(file)->implementation.xRead(p, iAmt, iOfst);
}
static int wrap_xWrite(sqlite3_file *file, const void *p, int iAmt, sqlite3_int64 iOfst) {
return static_cast<SQLiteFile *>(file)->implementation.xWrite(p, iAmt, iOfst);
}
static int wrap_xTruncate(sqlite3_file *file, sqlite3_int64 size) {
return static_cast<SQLiteFile *>(file)->implementation.xTruncate(size);
}
static int wrap_xSync(sqlite3_file *file, int flags) {
return static_cast<SQLiteFile *>(file)->implementation.xSync(flags);
}
static int wrap_xFileSize(sqlite3_file *file, sqlite3_int64 *pSize) {
return static_cast<SQLiteFile *>(file)->implementation.xFileSize(pSize);
}
static int wrap_xLock(sqlite3_file *file, int flags) {
return static_cast<SQLiteFile *>(file)->implementation.xLock(flags);
}
static int wrap_xUnlock(sqlite3_file *file, int flags) {
return static_cast<SQLiteFile *>(file)->implementation.xUnlock(flags);
}
static int wrap_xCheckReservedLock(sqlite3_file *file, int *pResOut) {
return static_cast<SQLiteFile *>(file)->implementation.xCheckReservedLock(pResOut);
}
static int wrap_xFileControl(sqlite3_file *file, int op, void *pArg) {
return static_cast<SQLiteFile *>(file)->implementation.xFileControl(op, pArg);
}
static int wrap_xSectorSize(sqlite3_file *file) {
return static_cast<SQLiteFile *>(file)->implementation.xSectorSize();
}
static int wrap_xDeviceCharacteristics(sqlite3_file *file) {
return static_cast<SQLiteFile *>(file)->implementation.xDeviceCharacteristics();
}
static int wrap_xShmMap(sqlite3_file *file, int iPg, int pgsz, int flags, void volatile**pp) {
return static_cast<SQLiteFile *>(file)->implementation.xShmMap(iPg, pgsz, flags, pp);
}
static int wrap_xShmLock(sqlite3_file *file, int offset, int n, int flags) {
return static_cast<SQLiteFile *>(file)->implementation.xShmLock(offset, n, flags);
}
static void wrap_xShmBarrier(sqlite3_file *file) {
return static_cast<SQLiteFile *>(file)->implementation.xShmBarrier();
}
static int wrap_xShmUnmap(sqlite3_file *file, int deleteFlag) {
return static_cast<SQLiteFile *>(file)->implementation.xShmUnmap(deleteFlag);
}
static int wrap_xFetch(sqlite3_file *file, sqlite3_int64 iOfst, int iAmt, void **pp) {
return static_cast<SQLiteFile *>(file)->implementation.xFetch(iOfst, iAmt, pp);
}
static int wrap_xUnfetch(sqlite3_file *file, sqlite3_int64 iOfst, void *p) {
return static_cast<SQLiteFile *>(file)->implementation.xUnfetch(iOfst, p);
}
};
/**
* SQLite VFS implementation with virtual methods for C++.
*
* The default method implementations forward execution to `original_vfs`.
*
* You should not create objects of this type manually.
* Instead, you should subclass it, overriding any of the methods necessary, and pass your subclass to `SQLiteVfs<>`.
*
* @tparam TFileImpl `SQLiteFileImpl` subclass
* @see https://sqlite.org/c3ref/vfs.html
*/
template<typename TFileImpl>
struct SQLiteVfsImpl {
using FileImpl = TFileImpl;
/**
* VFS used by the default method implementations.
*/
sqlite3_vfs *original_vfs;
/**
* Open the database.
*
* `file` is guaranteed to have been constructed using the default constructor.
* If you return `SQLITE_OK`, the `file` IO methods will be populated.
* Otherwise, IO methods will be set to NULL and `file` will be automatically destroyed.
*
* @see https://sqlite.org/c3ref/vfs.html
*/
virtual int xOpen(sqlite3_filename zName, SQLiteFile<TFileImpl> *file, int flags, int *pOutFlags) {
return original_vfs->xOpen(original_vfs, zName, file->original_file, flags, pOutFlags);
}
/// @see https://sqlite.org/c3ref/vfs.html
virtual int xDelete(const char *zName, int syncDir) {
return original_vfs->xDelete(original_vfs, zName, syncDir);
}
/// @see https://sqlite.org/c3ref/vfs.html
virtual int xAccess(const char *zName, int flags, int *pResOut) {
return original_vfs->xAccess(original_vfs, zName, flags, pResOut);
}
/// @see https://sqlite.org/c3ref/vfs.html
virtual int xFullPathname(const char *zName, int nOut, char *zOut) {
return original_vfs->xFullPathname(original_vfs, zName, nOut, zOut);
}
/// @see https://sqlite.org/c3ref/vfs.html
virtual void *xDlOpen(const char *zFilename) {
return original_vfs->xDlOpen(original_vfs, zFilename);
}
/// @see https://sqlite.org/c3ref/vfs.html
virtual void xDlError(int nByte, char *zErrMsg) {
original_vfs->xDlError(original_vfs, nByte, zErrMsg);
}
/// @see https://sqlite.org/c3ref/vfs.html
virtual void (*xDlSym(void *library, const char *zSymbol))(void) {
return original_vfs->xDlSym(original_vfs, library, zSymbol);
}
/// @see https://sqlite.org/c3ref/vfs.html
virtual void xDlClose(void *library) {
return original_vfs->xDlClose(original_vfs, library);
}
/// @see https://sqlite.org/c3ref/vfs.html
virtual int xRandomness(int nByte, char *zOut) {
return original_vfs->xRandomness(original_vfs, nByte, zOut);
}
/// @see https://sqlite.org/c3ref/vfs.html
virtual int xSleep(int microseconds) {
return original_vfs->xSleep(original_vfs, microseconds);
}
/// @see https://sqlite.org/c3ref/vfs.html
virtual int xCurrentTime(double *pResOut) {
return original_vfs->xCurrentTime(original_vfs, pResOut);
}
/// @see https://sqlite.org/c3ref/vfs.html
virtual int xGetLastError(int nByte, char *zOut) {
return original_vfs->xGetLastError(original_vfs, nByte, zOut);
}
/*
** The methods above are in version 1 of the sqlite_vfs object
** definition. Those that follow are added in version 2 or later
*/
/// @see https://sqlite.org/c3ref/vfs.html
virtual int xCurrentTimeInt64(sqlite3_int64 *pResOut) {
return original_vfs->xCurrentTimeInt64(original_vfs, pResOut);
}
/*
** The methods above are in versions 1 and 2 of the sqlite_vfs object.
** Those below are for version 3 and greater.
*/
/// @see https://sqlite.org/c3ref/vfs.html
virtual int xSetSystemCall(const char *zName, sqlite3_syscall_ptr ptr) {
return original_vfs->xSetSystemCall(original_vfs, zName, ptr);
}
/// @see https://sqlite.org/c3ref/vfs.html
virtual sqlite3_syscall_ptr xGetSystemCall(const char *zName) {
return original_vfs->xGetSystemCall(original_vfs, zName);
}
/// @see https://sqlite.org/c3ref/vfs.html
virtual const char *xNextSystemCall(const char *zName) {
return original_vfs->xNextSystemCall(original_vfs, zName);
}
/*
** The methods above are in versions 1 through 3 of the sqlite_vfs object.
** New fields may be appended in future versions. The iVersion
** value will increment whenever this happens.
*/
};
/**
* POD `sqlite3_vfs` subclass that forwards all invocations to an embedded object that inherits `SQLiteVfsImpl`.
*
* You should not subclass this type.
* Pass your `SQLiteVfsImpl` subclass as template argument instead.
*
* @tparam TVfsImpl `SQLiteVfsImpl` subclass
*/
template<typename TVfsImpl>
struct SQLiteVfs : public sqlite3_vfs {
using VfsImpl = TVfsImpl;
using FileImpl = typename VfsImpl::FileImpl;
/**
* VFS implementation object of the `SQLiteVfsImpl` subclass passed as template parameter to `SQLiteVfs<>`.
*/
VfsImpl implementation;
/**
* Construct a named VFS with the default VFS as base.
*
* @param name VFS name.
* @see SQLiteVfs(const char *, sqlite3_vfs *)
*/
SQLiteVfs(const char *name)
: SQLiteVfs(name, (sqlite3_vfs *) nullptr)
{
}
/**
* Construct a named VFS with the VFS named `base_vfs_name` as base.
*
* @param name VFS name.
* @param base_vfs_name Base VFS name, used to find the base VFS using `sqlite3_vfs_find`.
* @see SQLiteVfs(const char *, sqlite3_vfs *)
*/
SQLiteVfs(const char *name, const char *base_vfs_name)
: SQLiteVfs(name, sqlite3_vfs_find(base_vfs_name))
{
}
/**
* Construct a named VFS with `original_vfs` as base VFS.
*
* The `original_vfs` will be forwarded to the `implementation`.
*
* @warning If a VFS is registered with a name that is NULL or an empty string, then the behavior is undefined.
* @param name VFS name.
* @param original_vfs Base VFS. If NULL, the default VFS will be used instead.
* @see SQLiteVfs(const char *, sqlite3_vfs *)
*/
SQLiteVfs(const char *name, sqlite3_vfs *original_vfs)
: SQLiteVfs()
{
if (original_vfs == nullptr) {
original_vfs = sqlite3_vfs_find(nullptr);
}
implementation.original_vfs = original_vfs;
iVersion = original_vfs->iVersion;
szOsFile = (int) sizeof(SQLiteFile<FileImpl>) + original_vfs->szOsFile;
mxPathname = original_vfs->mxPathname;
zName = name;
}
/**
* Unregisters the VFS, just to be sure.
* @see unregister_vfs
*/
~SQLiteVfs() {
unregister_vfs();
}
/**
* Register the VFS in SQLite using `sqlite3_vfs_register`.
*
* The same VFS can be registered multiple times without injury.
* To make an existing VFS into the default VFS, register it again with `makeDefault` flag set.
*
* @param makeDefault Whether the VFS will be the new default VFS.
* @see https://sqlite.org/c3ref/vfs_find.html
*/
int register_vfs(bool makeDefault) {
return sqlite3_vfs_register(this, makeDefault);
}
/**
* Unregister the VFS in SQLite using `sqlite3_vfs_unregister`.
*
* If the default VFS is unregistered, another VFS is chosen as the default arbitrarily.
* @see https://sqlite.org/c3ref/vfs_find.html
*/
int unregister_vfs() {
return sqlite3_vfs_unregister(this);
}
/**
* Whether this VFS is registered in SQLite, checked using `sqlite3_vfs_find`.
*
* @see https://sqlite.org/c3ref/vfs_find.html
*/
bool is_registered() const {
return sqlite3_vfs_find(zName) == this;
}
private:
SQLiteVfs()
: implementation()
{
pNext = nullptr;
pAppData = nullptr;
xOpen = &wrap_xOpen;
xDelete = &wrap_xDelete;
xAccess = &wrap_xAccess;
xFullPathname = &wrap_xFullPathname;
xDlOpen = &wrap_xDlOpen;
xDlError = &wrap_xDlError;
xDlSym = &wrap_xDlSym;
xDlClose = &wrap_xDlClose;
xRandomness = &wrap_xRandomness;
xSleep = &wrap_xSleep;
xCurrentTime = &wrap_xCurrentTime;
xGetLastError = &wrap_xGetLastError;
xCurrentTimeInt64 = &wrap_xCurrentTimeInt64;
xSetSystemCall = &wrap_xSetSystemCall;
xGetSystemCall = &wrap_xGetSystemCall;
xNextSystemCall = &wrap_xNextSystemCall;
}
static int wrap_xOpen(sqlite3_vfs *vfs, sqlite3_filename zName, sqlite3_file *raw_file, int flags, int *pOutFlags) {
auto file = static_cast<SQLiteFile<FileImpl> *>(raw_file);
new (file) SQLiteFile<FileImpl>();
int result = static_cast<SQLiteVfs *>(vfs)->implementation.xOpen(zName, file, flags, pOutFlags);
file->setup(result);
if (result != SQLITE_OK) {
file->~SQLiteFile<FileImpl>();
}
return result;
}
static int wrap_xDelete(sqlite3_vfs *vfs, const char *zName, int syncDir) {
return static_cast<SQLiteVfs *>(vfs)->implementation.xDelete(zName, syncDir);
}
static int wrap_xAccess(sqlite3_vfs *vfs, const char *zName, int flags, int *pResOut) {
return static_cast<SQLiteVfs *>(vfs)->implementation.xAccess(zName, flags, pResOut);
}
static int wrap_xFullPathname(sqlite3_vfs *vfs, const char *zName, int nOut, char *zOut) {
return static_cast<SQLiteVfs *>(vfs)->implementation.xFullPathname(zName, nOut, zOut);
}
static void *wrap_xDlOpen(sqlite3_vfs *vfs, const char *zFilename) {
return static_cast<SQLiteVfs *>(vfs)->implementation.xDlOpen(zFilename);
}
static void wrap_xDlError(sqlite3_vfs *vfs, int nByte, char *zErrMsg) {
static_cast<SQLiteVfs *>(vfs)->implementation.xDlError(nByte, zErrMsg);
}
static void (*wrap_xDlSym(sqlite3_vfs *vfs, void *library, const char *zSymbol))(void) {
return static_cast<SQLiteVfs *>(vfs)->implementation.xDlSym(library, zSymbol);
}
static void wrap_xDlClose(sqlite3_vfs *vfs, void *library) {
return static_cast<SQLiteVfs *>(vfs)->implementation.xDlClose(library);
}
static int wrap_xRandomness(sqlite3_vfs *vfs, int nByte, char *zOut) {
return static_cast<SQLiteVfs *>(vfs)->implementation.xRandomness(nByte, zOut);
}
static int wrap_xSleep(sqlite3_vfs *vfs, int microseconds) {
return static_cast<SQLiteVfs *>(vfs)->implementation.xSleep(microseconds);
}
static int wrap_xCurrentTime(sqlite3_vfs *vfs, double *pResOut) {
return static_cast<SQLiteVfs *>(vfs)->implementation.xCurrentTime(pResOut);
}
static int wrap_xGetLastError(sqlite3_vfs *vfs, int nByte, char *zOut) {
return static_cast<SQLiteVfs *>(vfs)->implementation.xGetLastError(nByte, zOut);
}
static int wrap_xCurrentTimeInt64(sqlite3_vfs *vfs, sqlite3_int64 *pResOut) {
return static_cast<SQLiteVfs *>(vfs)->implementation.xCurrentTimeInt64(pResOut);
}
static int wrap_xSetSystemCall(sqlite3_vfs *vfs, const char *zName, sqlite3_syscall_ptr ptr) {
return static_cast<SQLiteVfs *>(vfs)->implementation.xSetSystemCall(zName, ptr);
}
static sqlite3_syscall_ptr wrap_xGetSystemCall(sqlite3_vfs *vfs, const char *zName) {
return static_cast<SQLiteVfs *>(vfs)->implementation.xGetSystemCall(zName);
}
static const char *wrap_xNextSystemCall(sqlite3_vfs *vfs, const char *zName) {
return static_cast<SQLiteVfs *>(vfs)->implementation.xNextSystemCall(zName);
}
};
}
#endif // __SQLITE_VFS_HPP__

View File

@@ -0,0 +1,106 @@
fileFormatVersion: 2
guid: aac1512bc2fa0445fbef81428fd172e6
PluginImporter:
externalObjects: {}
serializedVersion: 2
iconMap: {}
executionOrder: {}
defineConstraints: []
isPreloaded: 0
isOverridable: 1
isExplicitlyReferenced: 0
validateReferences: 1
platformData:
- first:
: Any
second:
enabled: 0
settings:
Exclude Android: 1
Exclude Editor: 1
Exclude Linux64: 1
Exclude OSXUniversal: 1
Exclude VisionOS: 1
Exclude WebGL: 0
Exclude Win: 1
Exclude Win64: 1
Exclude iOS: 1
Exclude tvOS: 1
- first:
Android: Android
second:
enabled: 0
settings:
AndroidSharedLibraryType: Executable
CPU: ARMv7
- first:
Any:
second:
enabled: 0
settings: {}
- first:
Editor: Editor
second:
enabled: 0
settings:
CPU: AnyCPU
DefaultValueInitialized: true
OS: AnyOS
- first:
Standalone: Linux64
second:
enabled: 0
settings:
CPU: None
- first:
Standalone: OSXUniversal
second:
enabled: 0
settings:
CPU: None
- first:
Standalone: Win
second:
enabled: 0
settings:
CPU: None
- first:
Standalone: Win64
second:
enabled: 0
settings:
CPU: None
- first:
VisionOS: VisionOS
second:
enabled: 0
settings:
AddToEmbeddedBinaries: false
CPU: ARM64
CompileFlags:
FrameworkDependencies:
- first:
WebGL: WebGL
second:
enabled: 1
settings: {}
- first:
iPhone: iOS
second:
enabled: 0
settings:
AddToEmbeddedBinaries: false
CPU: AnyCPU
CompileFlags:
FrameworkDependencies:
- first:
tvOS: tvOS
second:
enabled: 0
settings:
CPU: AnyCPU
CompileFlags:
FrameworkDependencies:
userData:
assetBundleName:
assetBundleVariant:

View File

@@ -0,0 +1,465 @@
/*
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
*
* For more information, please refer to <http://unlicense.org/>
*/
#include <cstdarg>
#include <cstdio>
#include <cstring>
#include <string>
#include <sys/stat.h>
#include <unistd.h>
#include <vector>
#include "SQLiteVfs.h"
#include "idbvfs.h"
/// Used size for Indexed DB "disk sectors"
#ifndef DISK_SECTOR_SIZE
#define DISK_SECTOR_SIZE 32
#endif
/// Indexed DB key used to store idbvfs file sizes
#define IDBVFS_SIZE_KEY "file_size"
#ifdef __EMSCRIPTEN__
#include <emscripten.h>
#define INLINE_JS(...) EM_ASM(__VA_ARGS__)
#else
#define INLINE_JS(...)
#endif
#ifdef TRACE
static void TRACE_LOG(const char *fmt, ...) {
va_list args;
va_start(args, fmt);
static char _idbvfs_trace_log_buffer[1024];
vsnprintf(_idbvfs_trace_log_buffer, sizeof(_idbvfs_trace_log_buffer), fmt, args);
#ifdef __EMSCRIPTEN__
EM_ASM({ console.log(UTF8ToString($0)) }, _idbvfs_trace_log_buffer);
#else
printf("%s\n", _idbvfs_trace_log_buffer);
#endif
va_end(args);
}
#else
#define TRACE_LOG(...)
#endif
using namespace sqlitevfs;
class IdbPage {
public:
IdbPage() {}
IdbPage(const char *dbname, const char *subfilename)
: dbname(dbname)
, filename(dbname)
{
filename.append("/");
filename.append(subfilename);
}
IdbPage(const char *dbname, int page_number)
: IdbPage(dbname, std::to_string(page_number).c_str())
{
}
bool exists() const {
if (FILE *f = fopen(filename.c_str(), "r")) {
fclose(f);
return true;
}
else {
return false;
}
}
int load_into(void *data, size_t data_size, sqlite3_int64 offset_in_page = 0) const {
if (FILE *f = fopen(filename.c_str(), "r")) {
if (offset_in_page > 0) {
fseek(f, offset_in_page, SEEK_SET);
}
size_t read_bytes = fread(data, 1, data_size, f);
fclose(f);
return read_bytes;
}
else {
return 0;
}
}
int load_into(std::vector<uint8_t>& out_buffer, size_t data_size) const {
out_buffer.resize(data_size);
return load_into(out_buffer.data(), data_size);
}
int scan_into(const char *fmt, ...) const {
if (FILE *f = fopen(filename.c_str(), "r")) {
va_list args;
va_start(args, fmt);
int assigned_items = vfscanf(f, fmt, args);
va_end(args);
fclose(f);
return assigned_items;
}
else {
return 0;
}
}
int store(const void *data, size_t data_size) const {
mkdir(dbname, 0777);
if (FILE *f = fopen(filename.c_str(), "w")) {
size_t written_bytes = fwrite(data, 1, data_size, f);
fclose(f);
return written_bytes;
}
else {
return 0;
}
}
int store(const std::vector<uint8_t>& data) const {
return store(data.data(), data.size());
}
int store(const std::string& data) const {
return store(data.c_str(), data.size());
}
bool remove() const {
return unlink(filename.c_str()) == 0;
}
private:
const char *dbname;
std::string filename;
};
struct IdbFileSize : public IdbPage {
IdbFileSize() : IdbPage() {}
IdbFileSize(sqlite3_filename file_name, bool autoload = true) : IdbPage(file_name, IDBVFS_SIZE_KEY) {
if (autoload) {
load();
}
}
void load() {
scan_into("%lu", &file_size);
is_dirty = false;
}
size_t get() const {
return file_size;
}
void set(size_t new_file_size) {
if (new_file_size != file_size) {
file_size = new_file_size;
is_dirty = true;
}
}
void update_if_greater(size_t new_file_size) {
if (new_file_size > file_size) {
set(new_file_size);
}
}
bool sync() const {
if (is_dirty) {
return store(std::to_string(file_size)) > 0;
}
else {
return true;
}
}
private:
size_t file_size = 0;
bool is_dirty = false;
};
struct IdbFile : public SQLiteFileImpl {
sqlite3_filename file_name;
IdbFileSize file_size;
std::vector<uint8_t> journal_data;
bool is_db;
IdbFile() {}
IdbFile(sqlite3_filename file_name, bool is_db) : file_name(file_name), file_size(file_name), is_db(is_db) {}
int iVersion() const override {
return 1;
}
int xClose() override {
return SQLITE_OK;
}
int xRead(void *p, int iAmt, sqlite3_int64 iOfst) override {
TRACE_LOG("READ %s %d @ %ld", file_name, iAmt, iOfst);
if (iAmt + iOfst > file_size.get()) {
TRACE_LOG(" > %d", false);
return SQLITE_IOERR_SHORT_READ;
}
int result;
if (is_db) {
result = readDb(p, iAmt, iOfst);
}
else {
result = readJournal(p, iAmt, iOfst);
}
TRACE_LOG(" > %d", result);
return result;
}
int xWrite(const void *p, int iAmt, sqlite3_int64 iOfst) override {
TRACE_LOG("WRITE %s %d @ %ld", file_name, iAmt, iOfst);
int result;
if (is_db) {
result = writeDb(p, iAmt, iOfst);
}
else {
result = writeJournal(p, iAmt, iOfst);
}
TRACE_LOG(" > %d", result);
return result;
}
int xTruncate(sqlite3_int64 size) override {
TRACE_LOG("TRUNCATE %s to %ld", file_name, size);
file_size.set(size);
TRACE_LOG(" > %d", true);
return SQLITE_OK;
}
int xSync(int flags) override {
TRACE_LOG("SYNC %s %d", file_name, flags);
// journal data is stored in-memory and synced all at once
if (!journal_data.empty()) {
IdbPage file(file_name, 0);
file.store(journal_data);
file_size.set(journal_data.size());
}
bool success = file_size.sync();
INLINE_JS({
Module.idbvfsSyncfs();
});
TRACE_LOG(" > %d", success);
return success ? SQLITE_OK : SQLITE_IOERR_FSYNC;
}
int xFileSize(sqlite3_int64 *pSize) override {
TRACE_LOG("FILE SIZE %s", file_name);
if (!journal_data.empty()) {
*pSize = journal_data.size();
}
else {
*pSize = file_size.get();
}
TRACE_LOG(" > %d", *pSize);
return SQLITE_OK;
}
int xLock(int flags) override {
return SQLITE_OK;
}
int xUnlock(int flags) override {
return SQLITE_OK;
}
int xCheckReservedLock(int *pResOut) override {
*pResOut = 0;
return SQLITE_OK;
}
int xFileControl(int op, void *pArg) override {
switch (op) {
case SQLITE_FCNTL_VFSNAME:
*(char **) pArg = sqlite3_mprintf("%z", IDBVFS_NAME);
return SQLITE_OK;
}
return SQLITE_NOTFOUND;
}
int xSectorSize() override {
return DISK_SECTOR_SIZE;
}
int xDeviceCharacteristics() override {
return 0;
}
private:
int readDb(void *p, int iAmt, sqlite3_int64 iOfst) {
int page_number;
sqlite3_int64 offset_in_page;
if (iOfst + iAmt >= 512) {
if (iOfst % iAmt != 0) {
return SQLITE_IOERR_READ;
}
page_number = iOfst / iAmt;
offset_in_page = 0;
} else {
page_number = 0;
offset_in_page = iOfst;
}
IdbPage page(file_name, page_number);
int loaded_bytes = page.load_into((uint8_t*) p, iAmt, offset_in_page);
if (loaded_bytes < iAmt) {
return SQLITE_IOERR_SHORT_READ;
}
else {
return SQLITE_OK;
}
}
int readJournal(void *p, int iAmt, sqlite3_int64 iOfst) {
if (journal_data.empty()) {
size_t journal_size = file_size.get();
if (journal_size > 0) {
IdbPage page(file_name, 0);
page.load_into(journal_data, journal_size);
}
}
if (iAmt + iOfst > journal_data.size()) {
return SQLITE_IOERR_SHORT_READ;
}
memcpy(p, journal_data.data() + iOfst, iAmt);
return SQLITE_OK;
}
int writeDb(const void *p, int iAmt, sqlite3_int64 iOfst) {
int page_number = iOfst ? iOfst / iAmt : 0;
IdbPage page(file_name, page_number);
int stored_bytes = page.store(p, iAmt);
if (stored_bytes < iAmt) {
return SQLITE_IOERR_WRITE;
}
file_size.update_if_greater(iAmt + iOfst);
return SQLITE_OK;
}
int writeJournal(const void *p, int iAmt, sqlite3_int64 iOfst) {
if (iAmt + iOfst > journal_data.size()) {
journal_data.resize(iAmt + iOfst);
}
memcpy(journal_data.data() + iOfst, p, iAmt);
return SQLITE_OK;
}
};
struct IdbVfs : public SQLiteVfsImpl<IdbFile> {
int xOpen(sqlite3_filename zName, SQLiteFile<IdbFile> *file, int flags, int *pOutFlags) override {
TRACE_LOG("OPEN %s", zName);
bool is_db = (flags & SQLITE_OPEN_MAIN_DB) || (flags & SQLITE_OPEN_TEMP_DB);
file->implementation = IdbFile(zName, is_db);
return SQLITE_OK;
}
int xDelete(const char *zName, int syncDir) override {
TRACE_LOG("DELETE %s", zName);
IdbFileSize file_size(zName, false);
if (!file_size.remove()) {
return SQLITE_IOERR_DELETE;
}
for (int i = 0; ; i++) {
IdbPage page(zName, i);
if (!page.remove()) {
break;
}
}
rmdir(zName);
return SQLITE_OK;
}
int xAccess(const char *zName, int flags, int *pResOut) override {
TRACE_LOG("ACCESS %s %d", zName, flags);
switch (flags) {
case SQLITE_ACCESS_EXISTS:
case SQLITE_ACCESS_READWRITE:
case SQLITE_ACCESS_READ:
IdbFileSize file_size(zName, false);
*pResOut = file_size.exists();
TRACE_LOG(" > %d", *pResOut);
return SQLITE_OK;
}
return SQLITE_NOTFOUND;
}
#ifdef __EMSCRIPTEN__
int xFullPathname(const char *zName, int nOut, char *zOut) override {
TRACE_LOG("FULL PATH %s", zName);
if (zName[0] == '/') {
strncpy(zOut, zName, nOut);
}
else {
snprintf(zOut, nOut, "/idbfs/%s", zName);
}
TRACE_LOG(" > %s", zOut);
return SQLITE_OK;
}
#endif
};
extern "C" {
const char *IDBVFS_NAME = "idbvfs";
int idbvfs_register(int makeDefault) {
static SQLiteVfs<IdbVfs> idbvfs(IDBVFS_NAME);
INLINE_JS({
if (!Module.idbvfsSyncfs) {
// Run FS.syncfs in a queue, to avoid concurrent execution errors
var syncQueue = 0;
function doSync() {
FS.syncfs(false, function() {
syncQueue--;
if (syncQueue > 0) {
doSync();
}
});
}
Module.idbvfsSyncfs = function() {
syncQueue++;
if (syncQueue == 1) {
doSync();
}
};
}
});
return idbvfs.register_vfs(makeDefault);
}
}

View File

@@ -0,0 +1,106 @@
fileFormatVersion: 2
guid: 33b221fa6bef54ac996317b3a8ab2021
PluginImporter:
externalObjects: {}
serializedVersion: 2
iconMap: {}
executionOrder: {}
defineConstraints: []
isPreloaded: 0
isOverridable: 1
isExplicitlyReferenced: 0
validateReferences: 1
platformData:
- first:
: Any
second:
enabled: 0
settings:
Exclude Android: 1
Exclude Editor: 1
Exclude Linux64: 1
Exclude OSXUniversal: 1
Exclude VisionOS: 1
Exclude WebGL: 0
Exclude Win: 1
Exclude Win64: 1
Exclude iOS: 1
Exclude tvOS: 1
- first:
Android: Android
second:
enabled: 0
settings:
AndroidSharedLibraryType: Executable
CPU: ARMv7
- first:
Any:
second:
enabled: 0
settings: {}
- first:
Editor: Editor
second:
enabled: 0
settings:
CPU: AnyCPU
DefaultValueInitialized: true
OS: AnyOS
- first:
Standalone: Linux64
second:
enabled: 0
settings:
CPU: None
- first:
Standalone: OSXUniversal
second:
enabled: 0
settings:
CPU: None
- first:
Standalone: Win
second:
enabled: 0
settings:
CPU: None
- first:
Standalone: Win64
second:
enabled: 0
settings:
CPU: None
- first:
VisionOS: VisionOS
second:
enabled: 0
settings:
AddToEmbeddedBinaries: false
CPU: ARM64
CompileFlags:
FrameworkDependencies:
- first:
WebGL: WebGL
second:
enabled: 1
settings: {}
- first:
iPhone: iOS
second:
enabled: 0
settings:
AddToEmbeddedBinaries: false
CPU: AnyCPU
CompileFlags:
FrameworkDependencies:
- first:
tvOS: tvOS
second:
enabled: 0
settings:
CPU: AnyCPU
CompileFlags:
FrameworkDependencies:
userData:
assetBundleName:
assetBundleVariant:

View File

@@ -0,0 +1,51 @@
/** @file idbvfs.h
*
* SQLite VFS that stores data in web browser's Indexed DB using Emscripten.
*/
/*
* This is free and unencumbered software released into the public domain.
*
* Anyone is free to copy, modify, publish, use, compile, sell, or
* distribute this software, either in source code form or as a compiled
* binary, for any purpose, commercial or non-commercial, and by any
* means.
*
* In jurisdictions that recognize copyright laws, the author or authors
* of this software dedicate any and all copyright interest in the
* software to the public domain. We make this dedication for the benefit
* of the public at large and to the detriment of our heirs and
* successors. We intend this dedication to be an overt act of
* relinquishment in perpetuity of all present and future rights to this
* software under copyright law.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
*
* For more information, please refer to <http://unlicense.org/>
*/
#ifdef __cplusplus
extern "C" {
#endif
/**
* String containing idbvfs name.
*/
extern const char *IDBVFS_NAME;
/**
* Registers idbvfs in SQLite 3.
*
* @param makeDefault Whether idbvfs will be the new default VFS.
* @return Return value from `sqlite3_vfs_register`
* @see https://sqlite.org/c3ref/vfs_find.html
*/
int idbvfs_register(int makeDefault);
#ifdef __cplusplus
}
#endif

View File

@@ -0,0 +1,106 @@
fileFormatVersion: 2
guid: 714e36bffffff4eeca3e5b12e47510eb
PluginImporter:
externalObjects: {}
serializedVersion: 2
iconMap: {}
executionOrder: {}
defineConstraints: []
isPreloaded: 0
isOverridable: 1
isExplicitlyReferenced: 0
validateReferences: 1
platformData:
- first:
: Any
second:
enabled: 0
settings:
Exclude Android: 1
Exclude Editor: 1
Exclude Linux64: 1
Exclude OSXUniversal: 1
Exclude VisionOS: 1
Exclude WebGL: 0
Exclude Win: 1
Exclude Win64: 1
Exclude iOS: 1
Exclude tvOS: 1
- first:
Android: Android
second:
enabled: 0
settings:
AndroidSharedLibraryType: Executable
CPU: ARMv7
- first:
Any:
second:
enabled: 0
settings: {}
- first:
Editor: Editor
second:
enabled: 0
settings:
CPU: AnyCPU
DefaultValueInitialized: true
OS: AnyOS
- first:
Standalone: Linux64
second:
enabled: 0
settings:
CPU: None
- first:
Standalone: OSXUniversal
second:
enabled: 0
settings:
CPU: None
- first:
Standalone: Win
second:
enabled: 0
settings:
CPU: None
- first:
Standalone: Win64
second:
enabled: 0
settings:
CPU: None
- first:
VisionOS: VisionOS
second:
enabled: 0
settings:
AddToEmbeddedBinaries: false
CPU: ARM64
CompileFlags:
FrameworkDependencies:
- first:
WebGL: WebGL
second:
enabled: 1
settings: {}
- first:
iPhone: iOS
second:
enabled: 0
settings:
AddToEmbeddedBinaries: false
CPU: AnyCPU
CompileFlags:
FrameworkDependencies:
- first:
tvOS: tvOS
second:
enabled: 0
settings:
CPU: AnyCPU
CompileFlags:
FrameworkDependencies:
userData:
assetBundleName:
assetBundleVariant:

View File

@@ -0,0 +1,8 @@
fileFormatVersion: 2
guid: 643c7bd7804e942b597f2f4a297fb3a9
folderAsset: yes
DefaultImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

View File

@@ -0,0 +1,8 @@
fileFormatVersion: 2
guid: 475700be16f36411b950cc12259f8e0a
folderAsset: yes
DefaultImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

View File

@@ -0,0 +1,8 @@
fileFormatVersion: 2
guid: 60c565140771d401a95a1f1850ef8d2e
folderAsset: yes
DefaultImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

View File

@@ -0,0 +1,101 @@
fileFormatVersion: 2
guid: 57126b2d3bafb46e5a7a4ece8eb4d9f8
PluginImporter:
externalObjects: {}
serializedVersion: 2
iconMap: {}
executionOrder: {}
defineConstraints: []
isPreloaded: 0
isOverridable: 1
isExplicitlyReferenced: 0
validateReferences: 1
platformData:
- first:
: Any
second:
enabled: 0
settings:
Exclude Android: 0
Exclude Editor: 1
Exclude Linux64: 1
Exclude OSXUniversal: 1
Exclude VisionOS: 1
Exclude WebGL: 1
Exclude Win: 1
Exclude Win64: 1
Exclude iOS: 1
Exclude tvOS: 1
- first:
Android: Android
second:
enabled: 1
settings:
AndroidSharedLibraryType: Executable
CPU: ARMv7
- first:
Any:
second:
enabled: 0
settings: {}
- first:
Editor: Editor
second:
enabled: 0
settings:
CPU: AnyCPU
DefaultValueInitialized: true
OS: AnyOS
- first:
Standalone: Linux64
second:
enabled: 0
settings:
CPU: None
- first:
Standalone: OSXUniversal
second:
enabled: 0
settings:
CPU: None
- first:
Standalone: Win
second:
enabled: 0
settings:
CPU: None
- first:
Standalone: Win64
second:
enabled: 0
settings:
CPU: None
- first:
VisionOS: VisionOS
second:
enabled: 0
settings:
AddToEmbeddedBinaries: false
CPU: ARM64
CompileFlags:
FrameworkDependencies:
- first:
iPhone: iOS
second:
enabled: 0
settings:
AddToEmbeddedBinaries: false
CPU: AnyCPU
CompileFlags:
FrameworkDependencies:
- first:
tvOS: tvOS
second:
enabled: 0
settings:
CPU: AnyCPU
CompileFlags:
FrameworkDependencies:
userData:
assetBundleName:
assetBundleVariant:

View File

@@ -0,0 +1,8 @@
fileFormatVersion: 2
guid: bfbafd25ec1ee4915a65b807012dd5eb
folderAsset: yes
DefaultImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

View File

@@ -0,0 +1,101 @@
fileFormatVersion: 2
guid: 087f5264fe8f3450f8b0e9fd5c0f52d8
PluginImporter:
externalObjects: {}
serializedVersion: 2
iconMap: {}
executionOrder: {}
defineConstraints: []
isPreloaded: 0
isOverridable: 1
isExplicitlyReferenced: 0
validateReferences: 1
platformData:
- first:
: Any
second:
enabled: 0
settings:
Exclude Android: 0
Exclude Editor: 1
Exclude Linux64: 1
Exclude OSXUniversal: 1
Exclude VisionOS: 1
Exclude WebGL: 1
Exclude Win: 1
Exclude Win64: 1
Exclude iOS: 1
Exclude tvOS: 1
- first:
Android: Android
second:
enabled: 1
settings:
AndroidSharedLibraryType: Executable
CPU: ARM64
- first:
Any:
second:
enabled: 0
settings: {}
- first:
Editor: Editor
second:
enabled: 0
settings:
CPU: AnyCPU
DefaultValueInitialized: true
OS: AnyOS
- first:
Standalone: Linux64
second:
enabled: 0
settings:
CPU: None
- first:
Standalone: OSXUniversal
second:
enabled: 0
settings:
CPU: None
- first:
Standalone: Win
second:
enabled: 0
settings:
CPU: None
- first:
Standalone: Win64
second:
enabled: 0
settings:
CPU: None
- first:
VisionOS: VisionOS
second:
enabled: 0
settings:
AddToEmbeddedBinaries: false
CPU: ARM64
CompileFlags:
FrameworkDependencies:
- first:
iPhone: iOS
second:
enabled: 0
settings:
AddToEmbeddedBinaries: false
CPU: AnyCPU
CompileFlags:
FrameworkDependencies:
- first:
tvOS: tvOS
second:
enabled: 0
settings:
CPU: AnyCPU
CompileFlags:
FrameworkDependencies:
userData:
assetBundleName:
assetBundleVariant:

View File

@@ -0,0 +1,8 @@
fileFormatVersion: 2
guid: dfb87fba928c64a5b8facb61f2e0f711
folderAsset: yes
DefaultImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

View File

@@ -0,0 +1,101 @@
fileFormatVersion: 2
guid: 0af503a9536c24d738fdf908dfb115eb
PluginImporter:
externalObjects: {}
serializedVersion: 2
iconMap: {}
executionOrder: {}
defineConstraints: []
isPreloaded: 0
isOverridable: 1
isExplicitlyReferenced: 0
validateReferences: 1
platformData:
- first:
: Any
second:
enabled: 0
settings:
Exclude Android: 0
Exclude Editor: 1
Exclude Linux64: 1
Exclude OSXUniversal: 1
Exclude VisionOS: 1
Exclude WebGL: 1
Exclude Win: 1
Exclude Win64: 1
Exclude iOS: 1
Exclude tvOS: 1
- first:
Android: Android
second:
enabled: 1
settings:
AndroidSharedLibraryType: Executable
CPU: X86
- first:
Any:
second:
enabled: 0
settings: {}
- first:
Editor: Editor
second:
enabled: 0
settings:
CPU: AnyCPU
DefaultValueInitialized: true
OS: AnyOS
- first:
Standalone: Linux64
second:
enabled: 0
settings:
CPU: None
- first:
Standalone: OSXUniversal
second:
enabled: 0
settings:
CPU: None
- first:
Standalone: Win
second:
enabled: 0
settings:
CPU: None
- first:
Standalone: Win64
second:
enabled: 0
settings:
CPU: None
- first:
VisionOS: VisionOS
second:
enabled: 0
settings:
AddToEmbeddedBinaries: false
CPU: ARM64
CompileFlags:
FrameworkDependencies:
- first:
iPhone: iOS
second:
enabled: 0
settings:
AddToEmbeddedBinaries: false
CPU: AnyCPU
CompileFlags:
FrameworkDependencies:
- first:
tvOS: tvOS
second:
enabled: 0
settings:
CPU: AnyCPU
CompileFlags:
FrameworkDependencies:
userData:
assetBundleName:
assetBundleVariant:

View File

@@ -0,0 +1,8 @@
fileFormatVersion: 2
guid: e25ff9771419c407db33c391a0fdadd1
folderAsset: yes
DefaultImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

View File

@@ -0,0 +1,101 @@
fileFormatVersion: 2
guid: 31ad6577221064c96a1a580ff407e1a2
PluginImporter:
externalObjects: {}
serializedVersion: 2
iconMap: {}
executionOrder: {}
defineConstraints: []
isPreloaded: 0
isOverridable: 1
isExplicitlyReferenced: 0
validateReferences: 1
platformData:
- first:
: Any
second:
enabled: 0
settings:
Exclude Android: 0
Exclude Editor: 1
Exclude Linux64: 1
Exclude OSXUniversal: 1
Exclude VisionOS: 1
Exclude WebGL: 1
Exclude Win: 1
Exclude Win64: 1
Exclude iOS: 1
Exclude tvOS: 1
- first:
Android: Android
second:
enabled: 1
settings:
AndroidSharedLibraryType: Executable
CPU: X86_64
- first:
Any:
second:
enabled: 0
settings: {}
- first:
Editor: Editor
second:
enabled: 0
settings:
CPU: AnyCPU
DefaultValueInitialized: true
OS: AnyOS
- first:
Standalone: Linux64
second:
enabled: 0
settings:
CPU: None
- first:
Standalone: OSXUniversal
second:
enabled: 0
settings:
CPU: None
- first:
Standalone: Win
second:
enabled: 0
settings:
CPU: None
- first:
Standalone: Win64
second:
enabled: 0
settings:
CPU: None
- first:
VisionOS: VisionOS
second:
enabled: 0
settings:
AddToEmbeddedBinaries: false
CPU: ARM64
CompileFlags:
FrameworkDependencies:
- first:
iPhone: iOS
second:
enabled: 0
settings:
AddToEmbeddedBinaries: false
CPU: AnyCPU
CompileFlags:
FrameworkDependencies:
- first:
tvOS: tvOS
second:
enabled: 0
settings:
CPU: AnyCPU
CompileFlags:
FrameworkDependencies:
userData:
assetBundleName:
assetBundleVariant:

View File

@@ -0,0 +1,8 @@
fileFormatVersion: 2
guid: 806517e1ae9d2e84f994c6d6df651af0
folderAsset: yes
DefaultImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

View File

@@ -0,0 +1,8 @@
fileFormatVersion: 2
guid: 71084fb9a073785c49eb8aac28f0bbfc
folderAsset: yes
DefaultImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

View File

@@ -0,0 +1,101 @@
fileFormatVersion: 2
guid: a5ad070f93c93bc05afd06384d710b49
PluginImporter:
externalObjects: {}
serializedVersion: 2
iconMap: {}
executionOrder: {}
defineConstraints: []
isPreloaded: 0
isOverridable: 1
isExplicitlyReferenced: 0
validateReferences: 1
platformData:
- first:
: Any
second:
enabled: 0
settings:
Exclude Android: 1
Exclude Editor: 0
Exclude Linux64: 0
Exclude OSXUniversal: 1
Exclude VisionOS: 1
Exclude WebGL: 1
Exclude Win: 0
Exclude Win64: 0
Exclude iOS: 1
Exclude tvOS: 1
- first:
Android: Android
second:
enabled: 0
settings:
AndroidSharedLibraryType: Executable
CPU: ARMv7
- first:
Any:
second:
enabled: 0
settings: {}
- first:
Editor: Editor
second:
enabled: 1
settings:
CPU: x86_64
DefaultValueInitialized: true
OS: Linux
- first:
Standalone: Linux64
second:
enabled: 1
settings:
CPU: AnyCPU
- first:
Standalone: OSXUniversal
second:
enabled: 0
settings:
CPU: AnyCPU
- first:
Standalone: Win
second:
enabled: 1
settings:
CPU: AnyCPU
- first:
Standalone: Win64
second:
enabled: 1
settings:
CPU: AnyCPU
- first:
VisionOS: VisionOS
second:
enabled: 0
settings:
AddToEmbeddedBinaries: false
CPU: ARM64
CompileFlags:
FrameworkDependencies:
- first:
iPhone: iOS
second:
enabled: 0
settings:
AddToEmbeddedBinaries: false
CPU: AnyCPU
CompileFlags:
FrameworkDependencies:
- first:
tvOS: tvOS
second:
enabled: 0
settings:
CPU: AnyCPU
CompileFlags:
FrameworkDependencies:
userData:
assetBundleName:
assetBundleVariant:

View File

@@ -0,0 +1,8 @@
fileFormatVersion: 2
guid: e2b76ac96bd85474a97ccd9fb12e4220
folderAsset: yes
DefaultImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

View File

@@ -0,0 +1,82 @@
fileFormatVersion: 2
guid: 5ac500925e8a7402fabca3baf4eca437
PluginImporter:
externalObjects: {}
serializedVersion: 2
iconMap: {}
executionOrder: {}
defineConstraints: []
isPreloaded: 0
isOverridable: 1
isExplicitlyReferenced: 0
validateReferences: 1
platformData:
- first:
: Any
second:
enabled: 0
settings:
Exclude Android: 1
Exclude Editor: 0
Exclude Linux64: 1
Exclude OSXUniversal: 0
Exclude WebGL: 1
Exclude Win: 1
Exclude Win64: 1
Exclude iOS: 1
- first:
Android: Android
second:
enabled: 0
settings:
AndroidSharedLibraryType: Executable
CPU: ARMv7
- first:
Any:
second:
enabled: 0
settings: {}
- first:
Editor: Editor
second:
enabled: 1
settings:
CPU: AnyCPU
DefaultValueInitialized: true
OS: OSX
- first:
Standalone: Linux64
second:
enabled: 0
settings:
CPU: AnyCPU
- first:
Standalone: OSXUniversal
second:
enabled: 1
settings:
CPU: AnyCPU
- first:
Standalone: Win
second:
enabled: 0
settings:
CPU: AnyCPU
- first:
Standalone: Win64
second:
enabled: 0
settings:
CPU: AnyCPU
- first:
iPhone: iOS
second:
enabled: 0
settings:
AddToEmbeddedBinaries: false
CPU: AnyCPU
CompileFlags:
FrameworkDependencies:
userData:
assetBundleName:
assetBundleVariant:

View File

@@ -0,0 +1,8 @@
fileFormatVersion: 2
guid: ffde8862e849e442a9c6d9e16351bdb6
folderAsset: yes
DefaultImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

View File

@@ -0,0 +1,8 @@
fileFormatVersion: 2
guid: 49731d4518ba8405cb4a2da9941193a7
folderAsset: yes
DefaultImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

View File

@@ -0,0 +1,83 @@
fileFormatVersion: 2
guid: 6b53346b6b4b8438d8d3d69a36f38fc4
PluginImporter:
externalObjects: {}
serializedVersion: 2
iconMap: {}
executionOrder: {}
defineConstraints: []
isPreloaded: 0
isOverridable: 1
isExplicitlyReferenced: 0
validateReferences: 1
platformData:
- first:
: Any
second:
enabled: 0
settings:
Exclude Android: 1
Exclude Editor: 0
Exclude Linux64: 0
Exclude OSXUniversal: 0
Exclude WebGL: 1
Exclude Win: 1
Exclude Win64: 0
Exclude WindowsStoreApps: 0
- first:
Android: Android
second:
enabled: 0
settings:
AndroidSharedLibraryType: Executable
CPU: ARMv7
- first:
Any:
second:
enabled: 0
settings: {}
- first:
Editor: Editor
second:
enabled: 1
settings:
CPU: ARM64
DefaultValueInitialized: true
OS: Windows
- first:
Standalone: Linux64
second:
enabled: 1
settings:
CPU: AnyCPU
- first:
Standalone: OSXUniversal
second:
enabled: 1
settings:
CPU: AnyCPU
- first:
Standalone: Win
second:
enabled: 0
settings:
CPU: AnyCPU
- first:
Standalone: Win64
second:
enabled: 1
settings:
CPU: ARM64
- first:
Windows Store Apps: WindowsStoreApps
second:
enabled: 1
settings:
CPU: ARM64
DontProcess: false
PlaceholderPath:
SDK: AnySDK
ScriptingBackend: AnyScriptingBackend
userData:
assetBundleName:
assetBundleVariant:

View File

@@ -0,0 +1,8 @@
fileFormatVersion: 2
guid: 5d8321f9eff864a28863a1f1dfef2889
folderAsset: yes
DefaultImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

View File

@@ -0,0 +1,112 @@
fileFormatVersion: 2
guid: e350d0232f7f0422daaad868e5e48077
PluginImporter:
externalObjects: {}
serializedVersion: 2
iconMap: {}
executionOrder: {}
defineConstraints: []
isPreloaded: 0
isOverridable: 1
isExplicitlyReferenced: 0
validateReferences: 1
platformData:
- first:
: Any
second:
enabled: 0
settings:
Exclude Android: 1
Exclude Editor: 1
Exclude Linux64: 0
Exclude OSXUniversal: 0
Exclude VisionOS: 1
Exclude WebGL: 1
Exclude Win: 0
Exclude Win64: 1
Exclude WindowsStoreApps: 0
Exclude iOS: 1
Exclude tvOS: 1
- first:
Android: Android
second:
enabled: 0
settings:
AndroidSharedLibraryType: Executable
CPU: ARMv7
- first:
Any:
second:
enabled: 0
settings: {}
- first:
Editor: Editor
second:
enabled: 0
settings:
CPU: AnyCPU
DefaultValueInitialized: true
OS: AnyOS
- first:
Standalone: Linux64
second:
enabled: 1
settings:
CPU: AnyCPU
- first:
Standalone: OSXUniversal
second:
enabled: 1
settings:
CPU: AnyCPU
- first:
Standalone: Win
second:
enabled: 1
settings:
CPU: AnyCPU
- first:
Standalone: Win64
second:
enabled: 0
settings:
CPU: AnyCPU
- first:
VisionOS: VisionOS
second:
enabled: 0
settings:
AddToEmbeddedBinaries: false
CPU: ARM64
CompileFlags:
FrameworkDependencies:
- first:
Windows Store Apps: WindowsStoreApps
second:
enabled: 1
settings:
CPU: X86
DontProcess: false
PlaceholderPath:
SDK: AnySDK
ScriptingBackend: AnyScriptingBackend
- first:
iPhone: iOS
second:
enabled: 0
settings:
AddToEmbeddedBinaries: false
CPU: AnyCPU
CompileFlags:
FrameworkDependencies:
- first:
tvOS: tvOS
second:
enabled: 0
settings:
CPU: AnyCPU
CompileFlags:
FrameworkDependencies:
userData:
assetBundleName:
assetBundleVariant:

View File

@@ -0,0 +1,8 @@
fileFormatVersion: 2
guid: 4a09091ccc924403392207d037cc981e
folderAsset: yes
DefaultImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

View File

@@ -0,0 +1,112 @@
fileFormatVersion: 2
guid: 93d2b1d9e859c496e83bc487cf09cf57
PluginImporter:
externalObjects: {}
serializedVersion: 2
iconMap: {}
executionOrder: {}
defineConstraints: []
isPreloaded: 0
isOverridable: 1
isExplicitlyReferenced: 0
validateReferences: 1
platformData:
- first:
: Any
second:
enabled: 0
settings:
Exclude Android: 1
Exclude Editor: 0
Exclude Linux64: 0
Exclude OSXUniversal: 0
Exclude VisionOS: 1
Exclude WebGL: 1
Exclude Win: 1
Exclude Win64: 0
Exclude WindowsStoreApps: 0
Exclude iOS: 1
Exclude tvOS: 1
- first:
Android: Android
second:
enabled: 0
settings:
AndroidSharedLibraryType: Executable
CPU: ARMv7
- first:
Any:
second:
enabled: 0
settings: {}
- first:
Editor: Editor
second:
enabled: 1
settings:
CPU: x86_64
DefaultValueInitialized: true
OS: Windows
- first:
Standalone: Linux64
second:
enabled: 1
settings:
CPU: AnyCPU
- first:
Standalone: OSXUniversal
second:
enabled: 1
settings:
CPU: AnyCPU
- first:
Standalone: Win
second:
enabled: 0
settings:
CPU: AnyCPU
- first:
Standalone: Win64
second:
enabled: 1
settings:
CPU: AnyCPU
- first:
VisionOS: VisionOS
second:
enabled: 0
settings:
AddToEmbeddedBinaries: false
CPU: ARM64
CompileFlags:
FrameworkDependencies:
- first:
Windows Store Apps: WindowsStoreApps
second:
enabled: 1
settings:
CPU: X64
DontProcess: false
PlaceholderPath:
SDK: AnySDK
ScriptingBackend: AnyScriptingBackend
- first:
iPhone: iOS
second:
enabled: 0
settings:
AddToEmbeddedBinaries: false
CPU: AnyCPU
CompileFlags:
FrameworkDependencies:
- first:
tvOS: tvOS
second:
enabled: 0
settings:
CPU: AnyCPU
CompileFlags:
FrameworkDependencies:
userData:
assetBundleName:
assetBundleVariant:

View File

@@ -0,0 +1,8 @@
fileFormatVersion: 2
guid: b85a4855da6cd47cfa135c60a37af8c8
folderAsset: yes
DefaultImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

View File

@@ -0,0 +1,107 @@
fileFormatVersion: 2
guid: 4f4aecd216a78400d96ff7b4a39f0627
PluginImporter:
externalObjects: {}
serializedVersion: 2
iconMap: {}
executionOrder: {}
defineConstraints: []
isPreloaded: 0
isOverridable: 1
isExplicitlyReferenced: 0
validateReferences: 1
platformData:
- first:
: Any
second:
enabled: 0
settings:
Exclude Android: 1
Exclude Editor: 1
Exclude Linux64: 1
Exclude OSXUniversal: 1
Exclude VisionOS: 0
Exclude WebGL: 0
Exclude Win: 1
Exclude Win64: 1
Exclude iOS: 0
Exclude tvOS: 0
- first:
Android: Android
second:
enabled: 0
settings:
AndroidSharedLibraryType: Executable
CPU: ARMv7
- first:
Any:
second:
enabled: 0
settings: {}
- first:
Editor: Editor
second:
enabled: 0
settings:
CPU: AnyCPU
DefaultValueInitialized: true
OS: AnyOS
- first:
Standalone: Linux64
second:
enabled: 0
settings:
CPU: None
- first:
Standalone: OSXUniversal
second:
enabled: 0
settings:
CPU: None
- first:
Standalone: Win
second:
enabled: 0
settings:
CPU: None
- first:
Standalone: Win64
second:
enabled: 0
settings:
CPU: None
- first:
VisionOS: VisionOS
second:
enabled: 1
settings:
AddToEmbeddedBinaries: false
CPU: ARM64
CompileFlags:
FrameworkDependencies:
- first:
WebGL: WebGL
second:
enabled: 1
settings: {}
- first:
iPhone: iOS
second:
enabled: 1
settings:
AddToEmbeddedBinaries: false
CPU: AnyCPU
CompileFlags:
FrameworkDependencies:
- first:
tvOS: tvOS
second:
enabled: 1
settings:
AddToEmbeddedBinaries: false
CPU: AnyCPU
CompileFlags:
FrameworkDependencies:
userData:
assetBundleName:
assetBundleVariant:

View File

@@ -0,0 +1,86 @@
fileFormatVersion: 2
guid: bd619249260364d7c9e09aa0015418e6
PluginImporter:
externalObjects: {}
serializedVersion: 2
iconMap: {}
executionOrder: {}
defineConstraints: []
isPreloaded: 0
isOverridable: 1
isExplicitlyReferenced: 0
validateReferences: 1
platformData:
- first:
: Any
second:
enabled: 0
settings:
Exclude Android: 1
Exclude Editor: 1
Exclude Linux64: 1
Exclude OSXUniversal: 1
Exclude VisionOS: 0
Exclude WebGL: 0
Exclude Win: 1
Exclude Win64: 1
Exclude iOS: 0
Exclude tvOS: 0
- first:
Any:
second:
enabled: 0
settings: {}
- first:
Editor: Editor
second:
enabled: 0
settings:
DefaultValueInitialized: true
- first:
Standalone: Linux64
second:
enabled: 0
settings:
CPU: None
- first:
Standalone: OSXUniversal
second:
enabled: 0
settings:
CPU: None
- first:
Standalone: Win
second:
enabled: 0
settings:
CPU: None
- first:
Standalone: Win64
second:
enabled: 0
settings:
CPU: None
- first:
VisionOS: VisionOS
second:
enabled: 1
settings: {}
- first:
WebGL: WebGL
second:
enabled: 1
settings: {}
- first:
iPhone: iOS
second:
enabled: 1
settings: {}
- first:
tvOS: tvOS
second:
enabled: 1
settings: {}
userData:
assetBundleName:
assetBundleVariant:

View File

@@ -0,0 +1,19 @@
// Compile-time definitions used to build SQLite
// This is a separate file so that IL2CPP can use the same flags on all platforms
#define SQLITE_USE_URI 1
#define SQLITE_DQS 0
#define SQLITE_DEFAULT_MEMSTATUS 0
#define SQLITE_DEFAULT_WAL_SYNCHRONOUS 1
#define SQLITE_LIKE_DOESNT_MATCH_BLOBS 1
#define SQLITE_MAX_EXPR_DEPTH 0
#define SQLITE_OMIT_DECLTYPE 1
#define SQLITE_OMIT_DEPRECATED 1
#define SQLITE_OMIT_PROGRESS_CALLBACK 1
#define SQLITE_OMIT_SHARED_CACHE 1
#define SQLITE_USE_ALLOCA 1
#define SQLITE_ENABLE_RTREE 1
#define SQLITE_ENABLE_MATH_FUNCTIONS 1
#define HAVE_ISNAN 1
#define SQLITE_ENABLE_GEOPOLY 1
#define SQLITE_ENABLE_FTS5 1
#define SQLITE_ENABLE_HIDDEN_COLUMNS 1

View File

@@ -0,0 +1,107 @@
fileFormatVersion: 2
guid: 437dfc5ab03b74410aea0f06ebc8467b
PluginImporter:
externalObjects: {}
serializedVersion: 2
iconMap: {}
executionOrder: {}
defineConstraints: []
isPreloaded: 0
isOverridable: 1
isExplicitlyReferenced: 0
validateReferences: 1
platformData:
- first:
: Any
second:
enabled: 0
settings:
Exclude Android: 1
Exclude Editor: 1
Exclude Linux64: 1
Exclude OSXUniversal: 1
Exclude VisionOS: 0
Exclude WebGL: 0
Exclude Win: 1
Exclude Win64: 1
Exclude iOS: 0
Exclude tvOS: 0
- first:
Android: Android
second:
enabled: 0
settings:
AndroidSharedLibraryType: Executable
CPU: ARMv7
- first:
Any:
second:
enabled: 0
settings: {}
- first:
Editor: Editor
second:
enabled: 0
settings:
CPU: AnyCPU
DefaultValueInitialized: true
OS: AnyOS
- first:
Standalone: Linux64
second:
enabled: 0
settings:
CPU: None
- first:
Standalone: OSXUniversal
second:
enabled: 0
settings:
CPU: None
- first:
Standalone: Win
second:
enabled: 0
settings:
CPU: None
- first:
Standalone: Win64
second:
enabled: 0
settings:
CPU: None
- first:
VisionOS: VisionOS
second:
enabled: 1
settings:
AddToEmbeddedBinaries: false
CPU: AnyCPU
CompileFlags:
FrameworkDependencies:
- first:
WebGL: WebGL
second:
enabled: 1
settings: {}
- first:
iPhone: iOS
second:
enabled: 1
settings:
AddToEmbeddedBinaries: false
CPU: AnyCPU
CompileFlags:
FrameworkDependencies:
- first:
tvOS: tvOS
second:
enabled: 1
settings:
AddToEmbeddedBinaries: false
CPU: AnyCPU
CompileFlags:
FrameworkDependencies:
userData:
assetBundleName:
assetBundleVariant:

View File

@@ -0,0 +1,721 @@
#include "sqlite3_defines.h"
/*
** 2006 June 7
**
** The author disclaims copyright to this source code. In place of
** a legal notice, here is a blessing:
**
** May you do good and not evil.
** May you find forgiveness for yourself and forgive others.
** May you share freely, never taking more than you give.
**
*************************************************************************
** This header file defines the SQLite interface for use by
** shared libraries that want to be imported as extensions into
** an SQLite instance. Shared libraries that intend to be loaded
** as extensions by SQLite should #include this file instead of
** sqlite3.h.
*/
#ifndef SQLITE3EXT_H
#define SQLITE3EXT_H
#include "sqlite3.h"
/*
** The following structure holds pointers to all of the SQLite API
** routines.
**
** WARNING: In order to maintain backwards compatibility, add new
** interfaces to the end of this structure only. If you insert new
** interfaces in the middle of this structure, then older different
** versions of SQLite will not be able to load each other's shared
** libraries!
*/
struct sqlite3_api_routines {
void * (*aggregate_context)(sqlite3_context*,int nBytes);
int (*aggregate_count)(sqlite3_context*);
int (*bind_blob)(sqlite3_stmt*,int,const void*,int n,void(*)(void*));
int (*bind_double)(sqlite3_stmt*,int,double);
int (*bind_int)(sqlite3_stmt*,int,int);
int (*bind_int64)(sqlite3_stmt*,int,sqlite_int64);
int (*bind_null)(sqlite3_stmt*,int);
int (*bind_parameter_count)(sqlite3_stmt*);
int (*bind_parameter_index)(sqlite3_stmt*,const char*zName);
const char * (*bind_parameter_name)(sqlite3_stmt*,int);
int (*bind_text)(sqlite3_stmt*,int,const char*,int n,void(*)(void*));
int (*bind_text16)(sqlite3_stmt*,int,const void*,int,void(*)(void*));
int (*bind_value)(sqlite3_stmt*,int,const sqlite3_value*);
int (*busy_handler)(sqlite3*,int(*)(void*,int),void*);
int (*busy_timeout)(sqlite3*,int ms);
int (*changes)(sqlite3*);
int (*close)(sqlite3*);
int (*collation_needed)(sqlite3*,void*,void(*)(void*,sqlite3*,
int eTextRep,const char*));
int (*collation_needed16)(sqlite3*,void*,void(*)(void*,sqlite3*,
int eTextRep,const void*));
const void * (*column_blob)(sqlite3_stmt*,int iCol);
int (*column_bytes)(sqlite3_stmt*,int iCol);
int (*column_bytes16)(sqlite3_stmt*,int iCol);
int (*column_count)(sqlite3_stmt*pStmt);
const char * (*column_database_name)(sqlite3_stmt*,int);
const void * (*column_database_name16)(sqlite3_stmt*,int);
const char * (*column_decltype)(sqlite3_stmt*,int i);
const void * (*column_decltype16)(sqlite3_stmt*,int);
double (*column_double)(sqlite3_stmt*,int iCol);
int (*column_int)(sqlite3_stmt*,int iCol);
sqlite_int64 (*column_int64)(sqlite3_stmt*,int iCol);
const char * (*column_name)(sqlite3_stmt*,int);
const void * (*column_name16)(sqlite3_stmt*,int);
const char * (*column_origin_name)(sqlite3_stmt*,int);
const void * (*column_origin_name16)(sqlite3_stmt*,int);
const char * (*column_table_name)(sqlite3_stmt*,int);
const void * (*column_table_name16)(sqlite3_stmt*,int);
const unsigned char * (*column_text)(sqlite3_stmt*,int iCol);
const void * (*column_text16)(sqlite3_stmt*,int iCol);
int (*column_type)(sqlite3_stmt*,int iCol);
sqlite3_value* (*column_value)(sqlite3_stmt*,int iCol);
void * (*commit_hook)(sqlite3*,int(*)(void*),void*);
int (*complete)(const char*sql);
int (*complete16)(const void*sql);
int (*create_collation)(sqlite3*,const char*,int,void*,
int(*)(void*,int,const void*,int,const void*));
int (*create_collation16)(sqlite3*,const void*,int,void*,
int(*)(void*,int,const void*,int,const void*));
int (*create_function)(sqlite3*,const char*,int,int,void*,
void (*xFunc)(sqlite3_context*,int,sqlite3_value**),
void (*xStep)(sqlite3_context*,int,sqlite3_value**),
void (*xFinal)(sqlite3_context*));
int (*create_function16)(sqlite3*,const void*,int,int,void*,
void (*xFunc)(sqlite3_context*,int,sqlite3_value**),
void (*xStep)(sqlite3_context*,int,sqlite3_value**),
void (*xFinal)(sqlite3_context*));
int (*create_module)(sqlite3*,const char*,const sqlite3_module*,void*);
int (*data_count)(sqlite3_stmt*pStmt);
sqlite3 * (*db_handle)(sqlite3_stmt*);
int (*declare_vtab)(sqlite3*,const char*);
int (*enable_shared_cache)(int);
int (*errcode)(sqlite3*db);
const char * (*errmsg)(sqlite3*);
const void * (*errmsg16)(sqlite3*);
int (*exec)(sqlite3*,const char*,sqlite3_callback,void*,char**);
int (*expired)(sqlite3_stmt*);
int (*finalize)(sqlite3_stmt*pStmt);
void (*free)(void*);
void (*free_table)(char**result);
int (*get_autocommit)(sqlite3*);
void * (*get_auxdata)(sqlite3_context*,int);
int (*get_table)(sqlite3*,const char*,char***,int*,int*,char**);
int (*global_recover)(void);
void (*interruptx)(sqlite3*);
sqlite_int64 (*last_insert_rowid)(sqlite3*);
const char * (*libversion)(void);
int (*libversion_number)(void);
void *(*malloc)(int);
char * (*mprintf)(const char*,...);
int (*open)(const char*,sqlite3**);
int (*open16)(const void*,sqlite3**);
int (*prepare)(sqlite3*,const char*,int,sqlite3_stmt**,const char**);
int (*prepare16)(sqlite3*,const void*,int,sqlite3_stmt**,const void**);
void * (*profile)(sqlite3*,void(*)(void*,const char*,sqlite_uint64),void*);
void (*progress_handler)(sqlite3*,int,int(*)(void*),void*);
void *(*realloc)(void*,int);
int (*reset)(sqlite3_stmt*pStmt);
void (*result_blob)(sqlite3_context*,const void*,int,void(*)(void*));
void (*result_double)(sqlite3_context*,double);
void (*result_error)(sqlite3_context*,const char*,int);
void (*result_error16)(sqlite3_context*,const void*,int);
void (*result_int)(sqlite3_context*,int);
void (*result_int64)(sqlite3_context*,sqlite_int64);
void (*result_null)(sqlite3_context*);
void (*result_text)(sqlite3_context*,const char*,int,void(*)(void*));
void (*result_text16)(sqlite3_context*,const void*,int,void(*)(void*));
void (*result_text16be)(sqlite3_context*,const void*,int,void(*)(void*));
void (*result_text16le)(sqlite3_context*,const void*,int,void(*)(void*));
void (*result_value)(sqlite3_context*,sqlite3_value*);
void * (*rollback_hook)(sqlite3*,void(*)(void*),void*);
int (*set_authorizer)(sqlite3*,int(*)(void*,int,const char*,const char*,
const char*,const char*),void*);
void (*set_auxdata)(sqlite3_context*,int,void*,void (*)(void*));
char * (*xsnprintf)(int,char*,const char*,...);
int (*step)(sqlite3_stmt*);
int (*table_column_metadata)(sqlite3*,const char*,const char*,const char*,
char const**,char const**,int*,int*,int*);
void (*thread_cleanup)(void);
int (*total_changes)(sqlite3*);
void * (*trace)(sqlite3*,void(*xTrace)(void*,const char*),void*);
int (*transfer_bindings)(sqlite3_stmt*,sqlite3_stmt*);
void * (*update_hook)(sqlite3*,void(*)(void*,int ,char const*,char const*,
sqlite_int64),void*);
void * (*user_data)(sqlite3_context*);
const void * (*value_blob)(sqlite3_value*);
int (*value_bytes)(sqlite3_value*);
int (*value_bytes16)(sqlite3_value*);
double (*value_double)(sqlite3_value*);
int (*value_int)(sqlite3_value*);
sqlite_int64 (*value_int64)(sqlite3_value*);
int (*value_numeric_type)(sqlite3_value*);
const unsigned char * (*value_text)(sqlite3_value*);
const void * (*value_text16)(sqlite3_value*);
const void * (*value_text16be)(sqlite3_value*);
const void * (*value_text16le)(sqlite3_value*);
int (*value_type)(sqlite3_value*);
char *(*vmprintf)(const char*,va_list);
/* Added ??? */
int (*overload_function)(sqlite3*, const char *zFuncName, int nArg);
/* Added by 3.3.13 */
int (*prepare_v2)(sqlite3*,const char*,int,sqlite3_stmt**,const char**);
int (*prepare16_v2)(sqlite3*,const void*,int,sqlite3_stmt**,const void**);
int (*clear_bindings)(sqlite3_stmt*);
/* Added by 3.4.1 */
int (*create_module_v2)(sqlite3*,const char*,const sqlite3_module*,void*,
void (*xDestroy)(void *));
/* Added by 3.5.0 */
int (*bind_zeroblob)(sqlite3_stmt*,int,int);
int (*blob_bytes)(sqlite3_blob*);
int (*blob_close)(sqlite3_blob*);
int (*blob_open)(sqlite3*,const char*,const char*,const char*,sqlite3_int64,
int,sqlite3_blob**);
int (*blob_read)(sqlite3_blob*,void*,int,int);
int (*blob_write)(sqlite3_blob*,const void*,int,int);
int (*create_collation_v2)(sqlite3*,const char*,int,void*,
int(*)(void*,int,const void*,int,const void*),
void(*)(void*));
int (*file_control)(sqlite3*,const char*,int,void*);
sqlite3_int64 (*memory_highwater)(int);
sqlite3_int64 (*memory_used)(void);
sqlite3_mutex *(*mutex_alloc)(int);
void (*mutex_enter)(sqlite3_mutex*);
void (*mutex_free)(sqlite3_mutex*);
void (*mutex_leave)(sqlite3_mutex*);
int (*mutex_try)(sqlite3_mutex*);
int (*open_v2)(const char*,sqlite3**,int,const char*);
int (*release_memory)(int);
void (*result_error_nomem)(sqlite3_context*);
void (*result_error_toobig)(sqlite3_context*);
int (*sleep)(int);
void (*soft_heap_limit)(int);
sqlite3_vfs *(*vfs_find)(const char*);
int (*vfs_register)(sqlite3_vfs*,int);
int (*vfs_unregister)(sqlite3_vfs*);
int (*xthreadsafe)(void);
void (*result_zeroblob)(sqlite3_context*,int);
void (*result_error_code)(sqlite3_context*,int);
int (*test_control)(int, ...);
void (*randomness)(int,void*);
sqlite3 *(*context_db_handle)(sqlite3_context*);
int (*extended_result_codes)(sqlite3*,int);
int (*limit)(sqlite3*,int,int);
sqlite3_stmt *(*next_stmt)(sqlite3*,sqlite3_stmt*);
const char *(*sql)(sqlite3_stmt*);
int (*status)(int,int*,int*,int);
int (*backup_finish)(sqlite3_backup*);
sqlite3_backup *(*backup_init)(sqlite3*,const char*,sqlite3*,const char*);
int (*backup_pagecount)(sqlite3_backup*);
int (*backup_remaining)(sqlite3_backup*);
int (*backup_step)(sqlite3_backup*,int);
const char *(*compileoption_get)(int);
int (*compileoption_used)(const char*);
int (*create_function_v2)(sqlite3*,const char*,int,int,void*,
void (*xFunc)(sqlite3_context*,int,sqlite3_value**),
void (*xStep)(sqlite3_context*,int,sqlite3_value**),
void (*xFinal)(sqlite3_context*),
void(*xDestroy)(void*));
int (*db_config)(sqlite3*,int,...);
sqlite3_mutex *(*db_mutex)(sqlite3*);
int (*db_status)(sqlite3*,int,int*,int*,int);
int (*extended_errcode)(sqlite3*);
void (*log)(int,const char*,...);
sqlite3_int64 (*soft_heap_limit64)(sqlite3_int64);
const char *(*sourceid)(void);
int (*stmt_status)(sqlite3_stmt*,int,int);
int (*strnicmp)(const char*,const char*,int);
int (*unlock_notify)(sqlite3*,void(*)(void**,int),void*);
int (*wal_autocheckpoint)(sqlite3*,int);
int (*wal_checkpoint)(sqlite3*,const char*);
void *(*wal_hook)(sqlite3*,int(*)(void*,sqlite3*,const char*,int),void*);
int (*blob_reopen)(sqlite3_blob*,sqlite3_int64);
int (*vtab_config)(sqlite3*,int op,...);
int (*vtab_on_conflict)(sqlite3*);
/* Version 3.7.16 and later */
int (*close_v2)(sqlite3*);
const char *(*db_filename)(sqlite3*,const char*);
int (*db_readonly)(sqlite3*,const char*);
int (*db_release_memory)(sqlite3*);
const char *(*errstr)(int);
int (*stmt_busy)(sqlite3_stmt*);
int (*stmt_readonly)(sqlite3_stmt*);
int (*stricmp)(const char*,const char*);
int (*uri_boolean)(const char*,const char*,int);
sqlite3_int64 (*uri_int64)(const char*,const char*,sqlite3_int64);
const char *(*uri_parameter)(const char*,const char*);
char *(*xvsnprintf)(int,char*,const char*,va_list);
int (*wal_checkpoint_v2)(sqlite3*,const char*,int,int*,int*);
/* Version 3.8.7 and later */
int (*auto_extension)(void(*)(void));
int (*bind_blob64)(sqlite3_stmt*,int,const void*,sqlite3_uint64,
void(*)(void*));
int (*bind_text64)(sqlite3_stmt*,int,const char*,sqlite3_uint64,
void(*)(void*),unsigned char);
int (*cancel_auto_extension)(void(*)(void));
int (*load_extension)(sqlite3*,const char*,const char*,char**);
void *(*malloc64)(sqlite3_uint64);
sqlite3_uint64 (*msize)(void*);
void *(*realloc64)(void*,sqlite3_uint64);
void (*reset_auto_extension)(void);
void (*result_blob64)(sqlite3_context*,const void*,sqlite3_uint64,
void(*)(void*));
void (*result_text64)(sqlite3_context*,const char*,sqlite3_uint64,
void(*)(void*), unsigned char);
int (*strglob)(const char*,const char*);
/* Version 3.8.11 and later */
sqlite3_value *(*value_dup)(const sqlite3_value*);
void (*value_free)(sqlite3_value*);
int (*result_zeroblob64)(sqlite3_context*,sqlite3_uint64);
int (*bind_zeroblob64)(sqlite3_stmt*, int, sqlite3_uint64);
/* Version 3.9.0 and later */
unsigned int (*value_subtype)(sqlite3_value*);
void (*result_subtype)(sqlite3_context*,unsigned int);
/* Version 3.10.0 and later */
int (*status64)(int,sqlite3_int64*,sqlite3_int64*,int);
int (*strlike)(const char*,const char*,unsigned int);
int (*db_cacheflush)(sqlite3*);
/* Version 3.12.0 and later */
int (*system_errno)(sqlite3*);
/* Version 3.14.0 and later */
int (*trace_v2)(sqlite3*,unsigned,int(*)(unsigned,void*,void*,void*),void*);
char *(*expanded_sql)(sqlite3_stmt*);
/* Version 3.18.0 and later */
void (*set_last_insert_rowid)(sqlite3*,sqlite3_int64);
/* Version 3.20.0 and later */
int (*prepare_v3)(sqlite3*,const char*,int,unsigned int,
sqlite3_stmt**,const char**);
int (*prepare16_v3)(sqlite3*,const void*,int,unsigned int,
sqlite3_stmt**,const void**);
int (*bind_pointer)(sqlite3_stmt*,int,void*,const char*,void(*)(void*));
void (*result_pointer)(sqlite3_context*,void*,const char*,void(*)(void*));
void *(*value_pointer)(sqlite3_value*,const char*);
int (*vtab_nochange)(sqlite3_context*);
int (*value_nochange)(sqlite3_value*);
const char *(*vtab_collation)(sqlite3_index_info*,int);
/* Version 3.24.0 and later */
int (*keyword_count)(void);
int (*keyword_name)(int,const char**,int*);
int (*keyword_check)(const char*,int);
sqlite3_str *(*str_new)(sqlite3*);
char *(*str_finish)(sqlite3_str*);
void (*str_appendf)(sqlite3_str*, const char *zFormat, ...);
void (*str_vappendf)(sqlite3_str*, const char *zFormat, va_list);
void (*str_append)(sqlite3_str*, const char *zIn, int N);
void (*str_appendall)(sqlite3_str*, const char *zIn);
void (*str_appendchar)(sqlite3_str*, int N, char C);
void (*str_reset)(sqlite3_str*);
int (*str_errcode)(sqlite3_str*);
int (*str_length)(sqlite3_str*);
char *(*str_value)(sqlite3_str*);
/* Version 3.25.0 and later */
int (*create_window_function)(sqlite3*,const char*,int,int,void*,
void (*xStep)(sqlite3_context*,int,sqlite3_value**),
void (*xFinal)(sqlite3_context*),
void (*xValue)(sqlite3_context*),
void (*xInv)(sqlite3_context*,int,sqlite3_value**),
void(*xDestroy)(void*));
/* Version 3.26.0 and later */
const char *(*normalized_sql)(sqlite3_stmt*);
/* Version 3.28.0 and later */
int (*stmt_isexplain)(sqlite3_stmt*);
int (*value_frombind)(sqlite3_value*);
/* Version 3.30.0 and later */
int (*drop_modules)(sqlite3*,const char**);
/* Version 3.31.0 and later */
sqlite3_int64 (*hard_heap_limit64)(sqlite3_int64);
const char *(*uri_key)(const char*,int);
const char *(*filename_database)(const char*);
const char *(*filename_journal)(const char*);
const char *(*filename_wal)(const char*);
/* Version 3.32.0 and later */
const char *(*create_filename)(const char*,const char*,const char*,
int,const char**);
void (*free_filename)(const char*);
sqlite3_file *(*database_file_object)(const char*);
/* Version 3.34.0 and later */
int (*txn_state)(sqlite3*,const char*);
/* Version 3.36.1 and later */
sqlite3_int64 (*changes64)(sqlite3*);
sqlite3_int64 (*total_changes64)(sqlite3*);
/* Version 3.37.0 and later */
int (*autovacuum_pages)(sqlite3*,
unsigned int(*)(void*,const char*,unsigned int,unsigned int,unsigned int),
void*, void(*)(void*));
/* Version 3.38.0 and later */
int (*error_offset)(sqlite3*);
int (*vtab_rhs_value)(sqlite3_index_info*,int,sqlite3_value**);
int (*vtab_distinct)(sqlite3_index_info*);
int (*vtab_in)(sqlite3_index_info*,int,int);
int (*vtab_in_first)(sqlite3_value*,sqlite3_value**);
int (*vtab_in_next)(sqlite3_value*,sqlite3_value**);
/* Version 3.39.0 and later */
int (*deserialize)(sqlite3*,const char*,unsigned char*,
sqlite3_int64,sqlite3_int64,unsigned);
unsigned char *(*serialize)(sqlite3*,const char *,sqlite3_int64*,
unsigned int);
const char *(*db_name)(sqlite3*,int);
/* Version 3.40.0 and later */
int (*value_encoding)(sqlite3_value*);
/* Version 3.41.0 and later */
int (*is_interrupted)(sqlite3*);
/* Version 3.43.0 and later */
int (*stmt_explain)(sqlite3_stmt*,int);
/* Version 3.44.0 and later */
void *(*get_clientdata)(sqlite3*,const char*);
int (*set_clientdata)(sqlite3*, const char*, void*, void(*)(void*));
};
/*
** This is the function signature used for all extension entry points. It
** is also defined in the file "loadext.c".
*/
typedef int (*sqlite3_loadext_entry)(
sqlite3 *db, /* Handle to the database. */
char **pzErrMsg, /* Used to set error string on failure. */
const sqlite3_api_routines *pThunk /* Extension API function pointers. */
);
/*
** The following macros redefine the API routines so that they are
** redirected through the global sqlite3_api structure.
**
** This header file is also used by the loadext.c source file
** (part of the main SQLite library - not an extension) so that
** it can get access to the sqlite3_api_routines structure
** definition. But the main library does not want to redefine
** the API. So the redefinition macros are only valid if the
** SQLITE_CORE macros is undefined.
*/
#if !defined(SQLITE_CORE) && !defined(SQLITE_OMIT_LOAD_EXTENSION)
#define sqlite3_aggregate_context sqlite3_api->aggregate_context
#ifndef SQLITE_OMIT_DEPRECATED
#define sqlite3_aggregate_count sqlite3_api->aggregate_count
#endif
#define sqlite3_bind_blob sqlite3_api->bind_blob
#define sqlite3_bind_double sqlite3_api->bind_double
#define sqlite3_bind_int sqlite3_api->bind_int
#define sqlite3_bind_int64 sqlite3_api->bind_int64
#define sqlite3_bind_null sqlite3_api->bind_null
#define sqlite3_bind_parameter_count sqlite3_api->bind_parameter_count
#define sqlite3_bind_parameter_index sqlite3_api->bind_parameter_index
#define sqlite3_bind_parameter_name sqlite3_api->bind_parameter_name
#define sqlite3_bind_text sqlite3_api->bind_text
#define sqlite3_bind_text16 sqlite3_api->bind_text16
#define sqlite3_bind_value sqlite3_api->bind_value
#define sqlite3_busy_handler sqlite3_api->busy_handler
#define sqlite3_busy_timeout sqlite3_api->busy_timeout
#define sqlite3_changes sqlite3_api->changes
#define sqlite3_close sqlite3_api->close
#define sqlite3_collation_needed sqlite3_api->collation_needed
#define sqlite3_collation_needed16 sqlite3_api->collation_needed16
#define sqlite3_column_blob sqlite3_api->column_blob
#define sqlite3_column_bytes sqlite3_api->column_bytes
#define sqlite3_column_bytes16 sqlite3_api->column_bytes16
#define sqlite3_column_count sqlite3_api->column_count
#define sqlite3_column_database_name sqlite3_api->column_database_name
#define sqlite3_column_database_name16 sqlite3_api->column_database_name16
#define sqlite3_column_decltype sqlite3_api->column_decltype
#define sqlite3_column_decltype16 sqlite3_api->column_decltype16
#define sqlite3_column_double sqlite3_api->column_double
#define sqlite3_column_int sqlite3_api->column_int
#define sqlite3_column_int64 sqlite3_api->column_int64
#define sqlite3_column_name sqlite3_api->column_name
#define sqlite3_column_name16 sqlite3_api->column_name16
#define sqlite3_column_origin_name sqlite3_api->column_origin_name
#define sqlite3_column_origin_name16 sqlite3_api->column_origin_name16
#define sqlite3_column_table_name sqlite3_api->column_table_name
#define sqlite3_column_table_name16 sqlite3_api->column_table_name16
#define sqlite3_column_text sqlite3_api->column_text
#define sqlite3_column_text16 sqlite3_api->column_text16
#define sqlite3_column_type sqlite3_api->column_type
#define sqlite3_column_value sqlite3_api->column_value
#define sqlite3_commit_hook sqlite3_api->commit_hook
#define sqlite3_complete sqlite3_api->complete
#define sqlite3_complete16 sqlite3_api->complete16
#define sqlite3_create_collation sqlite3_api->create_collation
#define sqlite3_create_collation16 sqlite3_api->create_collation16
#define sqlite3_create_function sqlite3_api->create_function
#define sqlite3_create_function16 sqlite3_api->create_function16
#define sqlite3_create_module sqlite3_api->create_module
#define sqlite3_create_module_v2 sqlite3_api->create_module_v2
#define sqlite3_data_count sqlite3_api->data_count
#define sqlite3_db_handle sqlite3_api->db_handle
#define sqlite3_declare_vtab sqlite3_api->declare_vtab
#define sqlite3_enable_shared_cache sqlite3_api->enable_shared_cache
#define sqlite3_errcode sqlite3_api->errcode
#define sqlite3_errmsg sqlite3_api->errmsg
#define sqlite3_errmsg16 sqlite3_api->errmsg16
#define sqlite3_exec sqlite3_api->exec
#ifndef SQLITE_OMIT_DEPRECATED
#define sqlite3_expired sqlite3_api->expired
#endif
#define sqlite3_finalize sqlite3_api->finalize
#define sqlite3_free sqlite3_api->free
#define sqlite3_free_table sqlite3_api->free_table
#define sqlite3_get_autocommit sqlite3_api->get_autocommit
#define sqlite3_get_auxdata sqlite3_api->get_auxdata
#define sqlite3_get_table sqlite3_api->get_table
#ifndef SQLITE_OMIT_DEPRECATED
#define sqlite3_global_recover sqlite3_api->global_recover
#endif
#define sqlite3_interrupt sqlite3_api->interruptx
#define sqlite3_last_insert_rowid sqlite3_api->last_insert_rowid
#define sqlite3_libversion sqlite3_api->libversion
#define sqlite3_libversion_number sqlite3_api->libversion_number
#define sqlite3_malloc sqlite3_api->malloc
#define sqlite3_mprintf sqlite3_api->mprintf
#define sqlite3_open sqlite3_api->open
#define sqlite3_open16 sqlite3_api->open16
#define sqlite3_prepare sqlite3_api->prepare
#define sqlite3_prepare16 sqlite3_api->prepare16
#define sqlite3_prepare_v2 sqlite3_api->prepare_v2
#define sqlite3_prepare16_v2 sqlite3_api->prepare16_v2
#define sqlite3_profile sqlite3_api->profile
#define sqlite3_progress_handler sqlite3_api->progress_handler
#define sqlite3_realloc sqlite3_api->realloc
#define sqlite3_reset sqlite3_api->reset
#define sqlite3_result_blob sqlite3_api->result_blob
#define sqlite3_result_double sqlite3_api->result_double
#define sqlite3_result_error sqlite3_api->result_error
#define sqlite3_result_error16 sqlite3_api->result_error16
#define sqlite3_result_int sqlite3_api->result_int
#define sqlite3_result_int64 sqlite3_api->result_int64
#define sqlite3_result_null sqlite3_api->result_null
#define sqlite3_result_text sqlite3_api->result_text
#define sqlite3_result_text16 sqlite3_api->result_text16
#define sqlite3_result_text16be sqlite3_api->result_text16be
#define sqlite3_result_text16le sqlite3_api->result_text16le
#define sqlite3_result_value sqlite3_api->result_value
#define sqlite3_rollback_hook sqlite3_api->rollback_hook
#define sqlite3_set_authorizer sqlite3_api->set_authorizer
#define sqlite3_set_auxdata sqlite3_api->set_auxdata
#define sqlite3_snprintf sqlite3_api->xsnprintf
#define sqlite3_step sqlite3_api->step
#define sqlite3_table_column_metadata sqlite3_api->table_column_metadata
#define sqlite3_thread_cleanup sqlite3_api->thread_cleanup
#define sqlite3_total_changes sqlite3_api->total_changes
#define sqlite3_trace sqlite3_api->trace
#ifndef SQLITE_OMIT_DEPRECATED
#define sqlite3_transfer_bindings sqlite3_api->transfer_bindings
#endif
#define sqlite3_update_hook sqlite3_api->update_hook
#define sqlite3_user_data sqlite3_api->user_data
#define sqlite3_value_blob sqlite3_api->value_blob
#define sqlite3_value_bytes sqlite3_api->value_bytes
#define sqlite3_value_bytes16 sqlite3_api->value_bytes16
#define sqlite3_value_double sqlite3_api->value_double
#define sqlite3_value_int sqlite3_api->value_int
#define sqlite3_value_int64 sqlite3_api->value_int64
#define sqlite3_value_numeric_type sqlite3_api->value_numeric_type
#define sqlite3_value_text sqlite3_api->value_text
#define sqlite3_value_text16 sqlite3_api->value_text16
#define sqlite3_value_text16be sqlite3_api->value_text16be
#define sqlite3_value_text16le sqlite3_api->value_text16le
#define sqlite3_value_type sqlite3_api->value_type
#define sqlite3_vmprintf sqlite3_api->vmprintf
#define sqlite3_vsnprintf sqlite3_api->xvsnprintf
#define sqlite3_overload_function sqlite3_api->overload_function
#define sqlite3_prepare_v2 sqlite3_api->prepare_v2
#define sqlite3_prepare16_v2 sqlite3_api->prepare16_v2
#define sqlite3_clear_bindings sqlite3_api->clear_bindings
#define sqlite3_bind_zeroblob sqlite3_api->bind_zeroblob
#define sqlite3_blob_bytes sqlite3_api->blob_bytes
#define sqlite3_blob_close sqlite3_api->blob_close
#define sqlite3_blob_open sqlite3_api->blob_open
#define sqlite3_blob_read sqlite3_api->blob_read
#define sqlite3_blob_write sqlite3_api->blob_write
#define sqlite3_create_collation_v2 sqlite3_api->create_collation_v2
#define sqlite3_file_control sqlite3_api->file_control
#define sqlite3_memory_highwater sqlite3_api->memory_highwater
#define sqlite3_memory_used sqlite3_api->memory_used
#define sqlite3_mutex_alloc sqlite3_api->mutex_alloc
#define sqlite3_mutex_enter sqlite3_api->mutex_enter
#define sqlite3_mutex_free sqlite3_api->mutex_free
#define sqlite3_mutex_leave sqlite3_api->mutex_leave
#define sqlite3_mutex_try sqlite3_api->mutex_try
#define sqlite3_open_v2 sqlite3_api->open_v2
#define sqlite3_release_memory sqlite3_api->release_memory
#define sqlite3_result_error_nomem sqlite3_api->result_error_nomem
#define sqlite3_result_error_toobig sqlite3_api->result_error_toobig
#define sqlite3_sleep sqlite3_api->sleep
#define sqlite3_soft_heap_limit sqlite3_api->soft_heap_limit
#define sqlite3_vfs_find sqlite3_api->vfs_find
#define sqlite3_vfs_register sqlite3_api->vfs_register
#define sqlite3_vfs_unregister sqlite3_api->vfs_unregister
#define sqlite3_threadsafe sqlite3_api->xthreadsafe
#define sqlite3_result_zeroblob sqlite3_api->result_zeroblob
#define sqlite3_result_error_code sqlite3_api->result_error_code
#define sqlite3_test_control sqlite3_api->test_control
#define sqlite3_randomness sqlite3_api->randomness
#define sqlite3_context_db_handle sqlite3_api->context_db_handle
#define sqlite3_extended_result_codes sqlite3_api->extended_result_codes
#define sqlite3_limit sqlite3_api->limit
#define sqlite3_next_stmt sqlite3_api->next_stmt
#define sqlite3_sql sqlite3_api->sql
#define sqlite3_status sqlite3_api->status
#define sqlite3_backup_finish sqlite3_api->backup_finish
#define sqlite3_backup_init sqlite3_api->backup_init
#define sqlite3_backup_pagecount sqlite3_api->backup_pagecount
#define sqlite3_backup_remaining sqlite3_api->backup_remaining
#define sqlite3_backup_step sqlite3_api->backup_step
#define sqlite3_compileoption_get sqlite3_api->compileoption_get
#define sqlite3_compileoption_used sqlite3_api->compileoption_used
#define sqlite3_create_function_v2 sqlite3_api->create_function_v2
#define sqlite3_db_config sqlite3_api->db_config
#define sqlite3_db_mutex sqlite3_api->db_mutex
#define sqlite3_db_status sqlite3_api->db_status
#define sqlite3_extended_errcode sqlite3_api->extended_errcode
#define sqlite3_log sqlite3_api->log
#define sqlite3_soft_heap_limit64 sqlite3_api->soft_heap_limit64
#define sqlite3_sourceid sqlite3_api->sourceid
#define sqlite3_stmt_status sqlite3_api->stmt_status
#define sqlite3_strnicmp sqlite3_api->strnicmp
#define sqlite3_unlock_notify sqlite3_api->unlock_notify
#define sqlite3_wal_autocheckpoint sqlite3_api->wal_autocheckpoint
#define sqlite3_wal_checkpoint sqlite3_api->wal_checkpoint
#define sqlite3_wal_hook sqlite3_api->wal_hook
#define sqlite3_blob_reopen sqlite3_api->blob_reopen
#define sqlite3_vtab_config sqlite3_api->vtab_config
#define sqlite3_vtab_on_conflict sqlite3_api->vtab_on_conflict
/* Version 3.7.16 and later */
#define sqlite3_close_v2 sqlite3_api->close_v2
#define sqlite3_db_filename sqlite3_api->db_filename
#define sqlite3_db_readonly sqlite3_api->db_readonly
#define sqlite3_db_release_memory sqlite3_api->db_release_memory
#define sqlite3_errstr sqlite3_api->errstr
#define sqlite3_stmt_busy sqlite3_api->stmt_busy
#define sqlite3_stmt_readonly sqlite3_api->stmt_readonly
#define sqlite3_stricmp sqlite3_api->stricmp
#define sqlite3_uri_boolean sqlite3_api->uri_boolean
#define sqlite3_uri_int64 sqlite3_api->uri_int64
#define sqlite3_uri_parameter sqlite3_api->uri_parameter
#define sqlite3_uri_vsnprintf sqlite3_api->xvsnprintf
#define sqlite3_wal_checkpoint_v2 sqlite3_api->wal_checkpoint_v2
/* Version 3.8.7 and later */
#define sqlite3_auto_extension sqlite3_api->auto_extension
#define sqlite3_bind_blob64 sqlite3_api->bind_blob64
#define sqlite3_bind_text64 sqlite3_api->bind_text64
#define sqlite3_cancel_auto_extension sqlite3_api->cancel_auto_extension
#define sqlite3_load_extension sqlite3_api->load_extension
#define sqlite3_malloc64 sqlite3_api->malloc64
#define sqlite3_msize sqlite3_api->msize
#define sqlite3_realloc64 sqlite3_api->realloc64
#define sqlite3_reset_auto_extension sqlite3_api->reset_auto_extension
#define sqlite3_result_blob64 sqlite3_api->result_blob64
#define sqlite3_result_text64 sqlite3_api->result_text64
#define sqlite3_strglob sqlite3_api->strglob
/* Version 3.8.11 and later */
#define sqlite3_value_dup sqlite3_api->value_dup
#define sqlite3_value_free sqlite3_api->value_free
#define sqlite3_result_zeroblob64 sqlite3_api->result_zeroblob64
#define sqlite3_bind_zeroblob64 sqlite3_api->bind_zeroblob64
/* Version 3.9.0 and later */
#define sqlite3_value_subtype sqlite3_api->value_subtype
#define sqlite3_result_subtype sqlite3_api->result_subtype
/* Version 3.10.0 and later */
#define sqlite3_status64 sqlite3_api->status64
#define sqlite3_strlike sqlite3_api->strlike
#define sqlite3_db_cacheflush sqlite3_api->db_cacheflush
/* Version 3.12.0 and later */
#define sqlite3_system_errno sqlite3_api->system_errno
/* Version 3.14.0 and later */
#define sqlite3_trace_v2 sqlite3_api->trace_v2
#define sqlite3_expanded_sql sqlite3_api->expanded_sql
/* Version 3.18.0 and later */
#define sqlite3_set_last_insert_rowid sqlite3_api->set_last_insert_rowid
/* Version 3.20.0 and later */
#define sqlite3_prepare_v3 sqlite3_api->prepare_v3
#define sqlite3_prepare16_v3 sqlite3_api->prepare16_v3
#define sqlite3_bind_pointer sqlite3_api->bind_pointer
#define sqlite3_result_pointer sqlite3_api->result_pointer
#define sqlite3_value_pointer sqlite3_api->value_pointer
/* Version 3.22.0 and later */
#define sqlite3_vtab_nochange sqlite3_api->vtab_nochange
#define sqlite3_value_nochange sqlite3_api->value_nochange
#define sqlite3_vtab_collation sqlite3_api->vtab_collation
/* Version 3.24.0 and later */
#define sqlite3_keyword_count sqlite3_api->keyword_count
#define sqlite3_keyword_name sqlite3_api->keyword_name
#define sqlite3_keyword_check sqlite3_api->keyword_check
#define sqlite3_str_new sqlite3_api->str_new
#define sqlite3_str_finish sqlite3_api->str_finish
#define sqlite3_str_appendf sqlite3_api->str_appendf
#define sqlite3_str_vappendf sqlite3_api->str_vappendf
#define sqlite3_str_append sqlite3_api->str_append
#define sqlite3_str_appendall sqlite3_api->str_appendall
#define sqlite3_str_appendchar sqlite3_api->str_appendchar
#define sqlite3_str_reset sqlite3_api->str_reset
#define sqlite3_str_errcode sqlite3_api->str_errcode
#define sqlite3_str_length sqlite3_api->str_length
#define sqlite3_str_value sqlite3_api->str_value
/* Version 3.25.0 and later */
#define sqlite3_create_window_function sqlite3_api->create_window_function
/* Version 3.26.0 and later */
#define sqlite3_normalized_sql sqlite3_api->normalized_sql
/* Version 3.28.0 and later */
#define sqlite3_stmt_isexplain sqlite3_api->stmt_isexplain
#define sqlite3_value_frombind sqlite3_api->value_frombind
/* Version 3.30.0 and later */
#define sqlite3_drop_modules sqlite3_api->drop_modules
/* Version 3.31.0 and later */
#define sqlite3_hard_heap_limit64 sqlite3_api->hard_heap_limit64
#define sqlite3_uri_key sqlite3_api->uri_key
#define sqlite3_filename_database sqlite3_api->filename_database
#define sqlite3_filename_journal sqlite3_api->filename_journal
#define sqlite3_filename_wal sqlite3_api->filename_wal
/* Version 3.32.0 and later */
#define sqlite3_create_filename sqlite3_api->create_filename
#define sqlite3_free_filename sqlite3_api->free_filename
#define sqlite3_database_file_object sqlite3_api->database_file_object
/* Version 3.34.0 and later */
#define sqlite3_txn_state sqlite3_api->txn_state
/* Version 3.36.1 and later */
#define sqlite3_changes64 sqlite3_api->changes64
#define sqlite3_total_changes64 sqlite3_api->total_changes64
/* Version 3.37.0 and later */
#define sqlite3_autovacuum_pages sqlite3_api->autovacuum_pages
/* Version 3.38.0 and later */
#define sqlite3_error_offset sqlite3_api->error_offset
#define sqlite3_vtab_rhs_value sqlite3_api->vtab_rhs_value
#define sqlite3_vtab_distinct sqlite3_api->vtab_distinct
#define sqlite3_vtab_in sqlite3_api->vtab_in
#define sqlite3_vtab_in_first sqlite3_api->vtab_in_first
#define sqlite3_vtab_in_next sqlite3_api->vtab_in_next
/* Version 3.39.0 and later */
#ifndef SQLITE_OMIT_DESERIALIZE
#define sqlite3_deserialize sqlite3_api->deserialize
#define sqlite3_serialize sqlite3_api->serialize
#endif
#define sqlite3_db_name sqlite3_api->db_name
/* Version 3.40.0 and later */
#define sqlite3_value_encoding sqlite3_api->value_encoding
/* Version 3.41.0 and later */
#define sqlite3_is_interrupted sqlite3_api->is_interrupted
/* Version 3.43.0 and later */
#define sqlite3_stmt_explain sqlite3_api->stmt_explain
/* Version 3.44.0 and later */
#define sqlite3_get_clientdata sqlite3_api->get_clientdata
#define sqlite3_set_clientdata sqlite3_api->set_clientdata
#endif /* !defined(SQLITE_CORE) && !defined(SQLITE_OMIT_LOAD_EXTENSION) */
#if !defined(SQLITE_CORE) && !defined(SQLITE_OMIT_LOAD_EXTENSION)
/* This case when the file really is being compiled as a loadable
** extension */
# define SQLITE_EXTENSION_INIT1 const sqlite3_api_routines *sqlite3_api=0;
# define SQLITE_EXTENSION_INIT2(v) sqlite3_api=v;
# define SQLITE_EXTENSION_INIT3 \
extern const sqlite3_api_routines *sqlite3_api;
#else
/* This case when the file is being statically linked into the
** application */
# define SQLITE_EXTENSION_INIT1 /*no-op*/
# define SQLITE_EXTENSION_INIT2(v) (void)v; /* unused parameter */
# define SQLITE_EXTENSION_INIT3 /*no-op*/
#endif
#endif /* SQLITE3EXT_H */

View File

@@ -0,0 +1,86 @@
fileFormatVersion: 2
guid: fcb4567f69dc44be68b6b71003de7ee8
PluginImporter:
externalObjects: {}
serializedVersion: 2
iconMap: {}
executionOrder: {}
defineConstraints: []
isPreloaded: 0
isOverridable: 1
isExplicitlyReferenced: 0
validateReferences: 1
platformData:
- first:
: Any
second:
enabled: 0
settings:
Exclude Android: 1
Exclude Editor: 1
Exclude Linux64: 1
Exclude OSXUniversal: 1
Exclude VisionOS: 0
Exclude WebGL: 0
Exclude Win: 1
Exclude Win64: 1
Exclude iOS: 0
Exclude tvOS: 0
- first:
Any:
second:
enabled: 0
settings: {}
- first:
Editor: Editor
second:
enabled: 0
settings:
DefaultValueInitialized: true
- first:
Standalone: Linux64
second:
enabled: 0
settings:
CPU: None
- first:
Standalone: OSXUniversal
second:
enabled: 0
settings:
CPU: None
- first:
Standalone: Win
second:
enabled: 0
settings:
CPU: None
- first:
Standalone: Win64
second:
enabled: 0
settings:
CPU: None
- first:
VisionOS: VisionOS
second:
enabled: 1
settings: {}
- first:
WebGL: WebGL
second:
enabled: 1
settings: {}
- first:
iPhone: iOS
second:
enabled: 1
settings: {}
- first:
tvOS: tvOS
second:
enabled: 1
settings: {}
userData:
assetBundleName:
assetBundleVariant:

View File

@@ -0,0 +1,117 @@
# SQLite-net for Unity
[![openupm](https://img.shields.io/npm/v/com.gilzoide.sqlite-net?label=openupm&registry_uri=https://package.openupm.com)](https://openupm.com/packages/com.gilzoide.sqlite-net/)
This package provides the excelent [SQLite-net](https://github.com/praeclarum/sqlite-net) library for accessing [SQLite](https://sqlite.org/) databases in Unity.
## Features
- [SQLite-net v1.9.172](https://github.com/praeclarum/sqlite-net/tree/v1.9.172)
+ Both synchronous and asynchronous APIs are available
+ `SQLiteConnection.Serialize` extension method for serializing a database to `byte[]` (reference: [SQLite Serialization](https://www.sqlite.org/c3ref/serialize.html)).
+ `SQLiteConnection.Deserialize` extension method for deserializing memory (`byte[]`, `NativeArray<byte>` or `ReadOnlySpan<byte>`) into an open database (reference: [SQLite Deserialization](https://www.sqlite.org/c3ref/deserialize.html)).
- [SQLite 3.49.0](https://sqlite.org/releaselog/3_49_0.html)
+ Enabled modules: [R\*Tree](https://sqlite.org/rtree.html), [Geopoly](https://sqlite.org/geopoly.html), [FTS5](https://sqlite.org/fts5.html), [Built-In Math Functions](https://www.sqlite.org/lang_mathfunc.html)
+ Supports Windows, Linux, macOS, WebGL, Android, iOS, tvOS and visionOS platforms
+ Supports persisting data in WebGL builds by using a [custom VFS backed by Indexed DB](https://github.com/gilzoide/idbvfs).
## Optional packages
- [SQLite Asset](https://github.com/gilzoide/unity-sqlite-asset): read-only SQLite database assets for Unity with scripted importer for ".sqlite", ".sqlite2" and ".sqlite3" files
- [SQLite Asset - CSV](https://github.com/gilzoide/unity-sqlite-asset-csv): easily import ".csv" files as read-only SQLite database assets
## How to install
Either:
- Use the [openupm registry](https://openupm.com/) and install this package using the [openupm-cli](https://github.com/openupm/openupm-cli):
```
openupm add com.gilzoide.sqlite-net
```
- Install using the [Unity Package Manager](https://docs.unity3d.com/Manual/upm-ui-giturl.html) with the following URL:
```
https://github.com/gilzoide/unity-sqlite-net.git#1.2.4
```
- Clone this repository or download a snapshot of it directly inside your project's `Assets` or `Packages` folder.
## Usage example
The following code demonstrates some of SQLite-net's core functionality.
Check out [SQLite-net's Wiki](https://github.com/praeclarum/sqlite-net/wiki) for more complete documentation on how to use the library.
```cs
using SQLite;
using UnityEngine;
// The library contains simple attributes that you can use
// to control the construction of tables, ORM style
public class Player
{
[PrimaryKey, AutoIncrement]
public int Id { get; set; }
public string Name { get; set; }
}
public class TestSQLite : MonoBehaviour
{
void Start()
{
// 1. Create a connection to the database.
// The special ":memory:" in-memory database and
// URIs like "file:///somefile" are also supported
var db = new SQLiteConnection($"{Application.persistentDataPath}/MyDb.db");
// 2. Once you have defined your entity, you can automatically
// generate tables in your database by calling CreateTable
db.CreateTable<Player>();
// 3. You can insert rows in the database using Insert
// The Insert call fills Id, which is marked with [AutoIncremented]
var newPlayer = new Player
{
Name = "gilzoide",
};
db.Insert(newPlayer);
Debug.Log($"Player new ID: {newPlayer.Id}");
// Similar methods exist for Update and Delete.
// 4.a The most straightforward way to query for data
// is using the Table method. This can take predicates
// for constraining via WHERE clauses and/or adding ORDER BY clauses
var query = db.Table<Player>().Where(p => p.Name.StartsWith("g"));
foreach (Player player in query)
{
Debug.Log($"Found player named {player.Name} with ID {player.Id}");
}
// 4.b You can also make queries at a low-level using the Query method
var players = db.Query<Player>("SELECT * FROM Player WHERE Id = ?", 1);
foreach (Player player in players)
{
Debug.Log($"Player with ID 1 is called {player.Name}");
}
// 5. You can perform low-level updates to the database using the Execute
// method, for example for running PRAGMAs or VACUUM
db.Execute("VACUUM");
}
}
```
## License
SQLite-net for Unity first-party code is licensed under the [MIT license](LICENSE.txt).
Third-party code:
- SQLite-net: [MIT license](Runtime/sqlite-net/LICENSE.txt)
- SQLite: [public domain](https://sqlite.org/copyright.html)
## Modifications made to SQLite-net source code
- The value of `LibraryPath` was changed from `sqlite3` to `__Internal` in WebGL/iOS/tvOS/visionOS builds and `gilzoide-sqlite-net` for other platforms.
This makes sure the prebuilt libraries are used instead of the ones provided by the system.
- `LibraryPath` is made public.
This is useful for libraries that want to bind additional native SQLite functions via P/Invoke.
- `SQLiteConnection.Quote` is made public.
This is useful for libraries making raw queries.
- `SQLite3.SetDirectory` is only defined in Windows platforms.
- Makes all column related attributes inherit `PreserveAttribute`, fixing errors on columns when managed code stripping is enabled.
- Changes the `TaskScheduler` used by the async API on WebGL to one that executes tasks on Unity's main thread.
- Fix support for struct return types in queries

View File

@@ -0,0 +1,7 @@
fileFormatVersion: 2
guid: 214de60a9f5c549c99ca8bb4fcd0bf66
TextScriptImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

View File

@@ -0,0 +1,8 @@
fileFormatVersion: 2
guid: 1594d2f9e43f5463da091729acbc1b73
folderAsset: yes
DefaultImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

View File

@@ -0,0 +1,14 @@
{
"name": "Gilzoide.SqliteNet",
"rootNamespace": "SQLite",
"references": [],
"includePlatforms": [],
"excludePlatforms": [],
"allowUnsafeCode": true,
"overrideReferences": false,
"precompiledReferences": [],
"autoReferenced": true,
"defineConstraints": [],
"versionDefines": [],
"noEngineReferences": false
}

View File

@@ -0,0 +1,7 @@
fileFormatVersion: 2
guid: 17f96cd3b93974f6493e51a2f25c1241
AssemblyDefinitionImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

View File

@@ -0,0 +1,23 @@
using System.Threading.Tasks;
using UnityEngine;
namespace SQLite
{
public static class SQLiteAsyncExtensions
{
#if UNITY_WEBGL
// WebGL builds cannot use background threads, so use a
// TaskScheduler that executes tasks on Unity's main thread.
public static TaskScheduler TaskScheduler { get; private set; }
[RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.SubsystemRegistration)]
private static void InitializeTaskScheduler()
{
TaskScheduler = TaskScheduler.FromCurrentSynchronizationContext();
}
#else
// On all other platforms, use the default TaskScheduler
public static TaskScheduler TaskScheduler => TaskScheduler.Default;
#endif
}
}

View File

@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: da6b73f57890c4a9ca69e882cd03e45e
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

View File

@@ -0,0 +1,112 @@
/*
* Copyright (c) 2024 Gil Barbosa Reis
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
using System;
using System.Runtime.InteropServices;
#if UNITY_2018_1_OR_NEWER
using Unity.Collections;
using Unity.Collections.LowLevel.Unsafe;
#endif
namespace SQLite
{
public static class SQLiteConnectionExtensions
{
public static byte[] Serialize(this SQLiteConnection db, string schema = null)
{
IntPtr buffer = SQLite3.Serialize(db.Handle, schema, out long size, SQLite3.SerializeFlags.None);
if (buffer == IntPtr.Zero)
{
return null;
}
try
{
var bytes = new byte[size];
Marshal.Copy(buffer, bytes, 0, (int) size);
return bytes;
}
finally
{
SQLite3.Free(buffer);
}
}
public static SQLiteConnection Deserialize(this SQLiteConnection db, byte[] buffer, string schema = null, SQLite3.DeserializeFlags flags = SQLite3.DeserializeFlags.None)
{
return Deserialize(db, buffer, buffer.LongLength, schema, flags);
}
public static SQLiteConnection Deserialize(this SQLiteConnection db, byte[] buffer, long usedSize, string schema = null, SQLite3.DeserializeFlags flags = SQLite3.DeserializeFlags.None)
{
SQLite3.Result result = SQLite3.Deserialize(db.Handle, schema, buffer, usedSize, buffer.LongLength, flags);
if (result != SQLite3.Result.OK)
{
throw SQLiteException.New(result, SQLite3.GetErrmsg(db.Handle));
}
return db;
}
#if UNITY_2018_1_OR_NEWER
public static SQLiteConnection Deserialize(this SQLiteConnection db, NativeArray<byte> buffer, string schema = null, SQLite3.DeserializeFlags flags = SQLite3.DeserializeFlags.None)
{
return Deserialize(db, buffer, buffer.Length, schema, flags);
}
public static SQLiteConnection Deserialize(this SQLiteConnection db, NativeArray<byte> buffer, long usedSize, string schema = null, SQLite3.DeserializeFlags flags = SQLite3.DeserializeFlags.None)
{
SQLite3.Result result;
unsafe
{
result = SQLite3.Deserialize(db.Handle, schema, buffer.GetUnsafePtr(), usedSize, buffer.Length, flags);
}
if (result != SQLite3.Result.OK)
{
throw SQLiteException.New(result, SQLite3.GetErrmsg(db.Handle));
}
return db;
}
#endif
#if UNITY_2021_2_OR_NEWER
public static SQLiteConnection Deserialize(this SQLiteConnection db, ReadOnlySpan<byte> buffer, string schema = null, SQLite3.DeserializeFlags flags = SQLite3.DeserializeFlags.None)
{
return Deserialize(db, buffer, buffer.Length, schema, flags);
}
public static SQLiteConnection Deserialize(this SQLiteConnection db, ReadOnlySpan<byte> buffer, long usedSize, string schema = null, SQLite3.DeserializeFlags flags = SQLite3.DeserializeFlags.None)
{
SQLite3.Result result;
unsafe
{
fixed (void* ptr = buffer)
{
result = SQLite3.Deserialize(db.Handle, schema, ptr, usedSize, buffer.Length, flags);
}
}
if (result != SQLite3.Result.OK)
{
throw SQLiteException.New(result, SQLite3.GetErrmsg(db.Handle));
}
return db;
}
#endif
}
}

View File

@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 30836eea2610b493c892439e371095e2
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

View File

@@ -0,0 +1,119 @@
/*
* Copyright (c) 2024 Gil Barbosa Reis
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
using System;
using System.Runtime.InteropServices;
namespace SQLite
{
public static partial class SQLite3
{
[Flags]
public enum SerializeFlags : uint
{
None,
NoCopy = 0x001, /* Do no memory allocations */
}
[Flags]
public enum DeserializeFlags : uint
{
None,
FreeOnClose = 1, /* Call sqlite3_free() on close */
Resizeable = 2, /* Resize using sqlite3_realloc64() */
ReadOnly = 4, /* Database is read-only */
}
[DllImport(LibraryPath, EntryPoint = "sqlite3_serialize", CallingConvention = CallingConvention.Cdecl)]
public static extern IntPtr Serialize(IntPtr db, [MarshalAs(UnmanagedType.LPStr)] string zSchema, out long piSize, SerializeFlags mFlags);
[DllImport(LibraryPath, EntryPoint = "sqlite3_deserialize", CallingConvention = CallingConvention.Cdecl)]
public static extern Result Deserialize(IntPtr db, [MarshalAs(UnmanagedType.LPStr)] string zSchema, byte[] pData, long szDb, long szBuf, DeserializeFlags mFlags);
[DllImport(LibraryPath, EntryPoint = "sqlite3_deserialize", CallingConvention = CallingConvention.Cdecl)]
public static unsafe extern Result Deserialize(IntPtr db, [MarshalAs(UnmanagedType.LPStr)] string zSchema, void* pData, long szDb, long szBuf, DeserializeFlags mFlags);
[DllImport(LibraryPath, EntryPoint = "sqlite3_malloc", CallingConvention = CallingConvention.Cdecl)]
public static extern IntPtr Malloc(int size);
[DllImport(LibraryPath, EntryPoint = "sqlite3_malloc64", CallingConvention = CallingConvention.Cdecl)]
public static extern IntPtr Malloc(long size);
[DllImport(LibraryPath, EntryPoint = "sqlite3_realloc", CallingConvention = CallingConvention.Cdecl)]
public static extern IntPtr Realloc(IntPtr ptr, int size);
[DllImport(LibraryPath, EntryPoint = "sqlite3_realloc64", CallingConvention = CallingConvention.Cdecl)]
public static extern IntPtr Realloc(IntPtr ptr, long size);
[DllImport(LibraryPath, EntryPoint = "sqlite3_free", CallingConvention = CallingConvention.Cdecl)]
public static extern void Free(IntPtr ptr);
[DllImport(LibraryPath, EntryPoint = "sqlite3_column_bytes16", CallingConvention = CallingConvention.Cdecl)]
public static extern int ColumnBytes16(IntPtr stmt, int index);
#if UNITY_WEBGL && !UNITY_EDITOR
[DllImport(LibraryPath, CallingConvention = CallingConvention.Cdecl)]
public static extern int idbvfs_register(int makeDefault);
#endif
static SQLite3()
{
#if UNITY_WEBGL && !UNITY_EDITOR
idbvfs_register(1);
#endif
}
}
public static class ISQLiteConnectionExtensions
{
public static int Insert<T>(this ISQLiteConnection connection, ref T obj)
{
object boxed = obj;
int result = connection.Insert(boxed);
obj = (T) boxed;
return result;
}
public static int Insert<T>(this ISQLiteConnection connection, ref T obj, Type objType)
{
object boxed = obj;
int result = connection.Insert(boxed, objType);
obj = (T) boxed;
return result;
}
public static int Insert<T>(this ISQLiteConnection connection, ref T obj, string extra)
{
object boxed = obj;
int result = connection.Insert(boxed, extra);
obj = (T) boxed;
return result;
}
public static int Insert<T>(this ISQLiteConnection connection, ref T obj, string extra, Type objType)
{
object boxed = obj;
int result = connection.Insert(boxed, extra, objType);
obj = (T) boxed;
return result;
}
}
}

View File

@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: e5efe130b84bb4bd48a419af53aaf741
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

View File

@@ -0,0 +1,265 @@
/*
* Copyright (c) 2024 Gil Barbosa Reis
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
using System;
using System.Collections.Generic;
using System.Runtime.InteropServices;
namespace SQLite
{
/// <summary>
/// Low level SQLite prepared statement object.
/// </summary>
/// <remarks>
/// Using this is the same as using prepared statments in the SQLite C API.
/// You need to bind all arguments to the statement, manually step for each row and until done, get values from the
/// returned columns, manually reset for subsequent executions, then dispose when not needed anymore.
/// </remarks>
public class SQLitePreparedStatement : IDisposable
{
private static readonly IntPtr SQLITE_STATIC = IntPtr.Zero;
private SQLiteConnection _db;
private IntPtr _preparedStatement;
public SQLitePreparedStatement(SQLiteConnection db, string statement)
{
if (db == null)
{
throw new ArgumentNullException(nameof(db));
}
_db = db;
_preparedStatement = SQLite3.Prepare2(db.Handle, statement);
}
~SQLitePreparedStatement()
{
Dispose();
}
public SQLite3.Result Reset()
{
ThrowIfDisposed();
return SQLite3.Reset(_preparedStatement);
}
public SQLite3.Result Bind(int index, bool value)
{
ThrowIfDisposed();
return (SQLite3.Result) SQLite3.BindInt(_preparedStatement, index, value ? 1 : 0);
}
public SQLite3.Result Bind(string name, bool value)
{
ThrowIfDisposed();
int index = SQLite3.BindParameterIndex(_preparedStatement, name);
return Bind(index, value);
}
public SQLite3.Result Bind(int index, int value)
{
ThrowIfDisposed();
return (SQLite3.Result) SQLite3.BindInt(_preparedStatement, index, value);
}
public SQLite3.Result Bind(string name, int value)
{
ThrowIfDisposed();
int index = SQLite3.BindParameterIndex(_preparedStatement, name);
return Bind(index, value);
}
public SQLite3.Result Bind(int index, long value)
{
ThrowIfDisposed();
return (SQLite3.Result) SQLite3.BindInt64(_preparedStatement, index, value);
}
public SQLite3.Result Bind(string name, long value)
{
ThrowIfDisposed();
int index = SQLite3.BindParameterIndex(_preparedStatement, name);
return Bind(index, value);
}
public SQLite3.Result Bind(int index, float value)
{
ThrowIfDisposed();
return (SQLite3.Result) SQLite3.BindDouble(_preparedStatement, index, value);
}
public SQLite3.Result Bind(string name, float value)
{
ThrowIfDisposed();
int index = SQLite3.BindParameterIndex(_preparedStatement, name);
return Bind(index, value);
}
public SQLite3.Result Bind(int index, double value)
{
ThrowIfDisposed();
return (SQLite3.Result) SQLite3.BindDouble(_preparedStatement, index, value);
}
public SQLite3.Result Bind(string name, double value)
{
ThrowIfDisposed();
int index = SQLite3.BindParameterIndex(_preparedStatement, name);
return Bind(index, value);
}
public SQLite3.Result Bind(int index, string value)
{
ThrowIfDisposed();
return (SQLite3.Result) SQLite3.BindText(_preparedStatement, index, value, value.Length * sizeof(char), SQLITE_STATIC);
}
public SQLite3.Result Bind(string name, string value)
{
ThrowIfDisposed();
int index = SQLite3.BindParameterIndex(_preparedStatement, name);
return Bind(index, value);
}
public SQLite3.Result Bind(int index, byte[] value)
{
ThrowIfDisposed();
return (SQLite3.Result) SQLite3.BindBlob(_preparedStatement, index, value, value.Length, SQLITE_STATIC);
}
public SQLite3.Result Bind(string name, byte[] value)
{
ThrowIfDisposed();
int index = SQLite3.BindParameterIndex(_preparedStatement, name);
return Bind(index, value);
}
public int BindParameterIndex(string name)
{
ThrowIfDisposed();
return SQLite3.BindParameterIndex(_preparedStatement, name);
}
public SQLite3.Result Step()
{
ThrowIfDisposed();
var result = SQLite3.Step(_preparedStatement);
if (result > SQLite3.Result.OK && result < SQLite3.Result.Row)
{
throw SQLiteException.New(result, SQLite3.GetErrmsg(_db.Handle));
}
return result;
}
public int GetColumnCount()
{
ThrowIfDisposed();
return SQLite3.ColumnCount(_preparedStatement);
}
public string GetColumnName(int column)
{
ThrowIfDisposed();
return SQLite3.ColumnName16(_preparedStatement, column);
}
public IEnumerable<string> EnumerateColumnNames()
{
for (int i = 0, columnCount = GetColumnCount(); i < columnCount; i++)
{
yield return GetColumnName(i);
}
}
public IEnumerable<string> EnumerateColumnsAsText()
{
for (int i = 0, columnCount = GetColumnCount(); i < columnCount; i++)
{
yield return GetString(i);
}
}
public bool GetBool(int column)
{
ThrowIfDisposed();
return SQLite3.ColumnInt(_preparedStatement, column) != 0;
}
public int GetInt(int column)
{
ThrowIfDisposed();
return SQLite3.ColumnInt(_preparedStatement, column);
}
public long GetLong(int column)
{
ThrowIfDisposed();
return SQLite3.ColumnInt64(_preparedStatement, column);
}
public float GetFloat(int column)
{
ThrowIfDisposed();
return (float) SQLite3.ColumnDouble(_preparedStatement, column);
}
public double GetDouble(int column)
{
ThrowIfDisposed();
return SQLite3.ColumnDouble(_preparedStatement, column);
}
public string GetString(int column)
{
ThrowIfDisposed();
IntPtr ptr = SQLite3.ColumnText16(_preparedStatement, column);
if (ptr == IntPtr.Zero)
{
return null;
}
int sizeInBytes = SQLite3.ColumnBytes16(_preparedStatement, column);
return Marshal.PtrToStringUni(ptr, sizeInBytes / sizeof(char));
}
public byte[] GetBytes(int column)
{
ThrowIfDisposed();
IntPtr blob = SQLite3.ColumnBlob(_preparedStatement, column);
if (blob == IntPtr.Zero)
{
return null;
}
int sizeInBytes = SQLite3.ColumnBytes(_preparedStatement, column);
var value = new byte[sizeInBytes];
Marshal.Copy(blob, value, 0, sizeInBytes);
return value;
}
public void Dispose()
{
SQLite3.Finalize(_preparedStatement);
_preparedStatement = IntPtr.Zero;
_db = null;
}
private void ThrowIfDisposed()
{
if (_preparedStatement == IntPtr.Zero)
{
throw new ObjectDisposedException(nameof(_preparedStatement));
}
}
}
}

View File

@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 4f832e590cb784ed490bb3c248063980
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

View File

@@ -0,0 +1,8 @@
fileFormatVersion: 2
guid: fdd42b002eaee4f7e9226d236c618bf7
folderAsset: yes
DefaultImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

View File

@@ -0,0 +1,29 @@
using System.Resources;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
// General Information about an assembly is controlled through the following
// set of attributes. Change these attribute values to modify the information
// associated with an assembly.
[assembly: AssemblyTitle("SQLite-net Official Portable Library")]
[assembly: AssemblyDescription("Light weight library providing easy SQLite database storage")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("Krueger Systems, Inc.")]
[assembly: AssemblyProduct("SQLite-net")]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCulture("")]
[assembly: NeutralResourcesLanguage("en")]
// Version information for an assembly consists of the following four values:
//
// Major Version
// Minor Version
// Build Number
// Revision
//
// You can specify all the values or you can default the Build and Revision Numbers
// by using the '*' as shown below:
// [assembly: AssemblyVersion("1.0.*")]
[assembly: AssemblyVersion("1.0.0.0")]
[assembly: AssemblyFileVersion("1.0.0.0")]

View File

@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 5c9be88643c0c40be8577f5969655b43
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

View File

@@ -0,0 +1,21 @@
Copyright (c) Krueger Systems, Inc.
All rights reserved.
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

View File

@@ -0,0 +1,7 @@
fileFormatVersion: 2
guid: 2c88e95b456274e3d8541f961a49a403
TextScriptImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

View File

@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 5ba12ff0c4a47416fbd764e8214ca6c9
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

View File

@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: cad9e8fa279d240a093308d4bad79e29
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

View File

@@ -0,0 +1,8 @@
fileFormatVersion: 2
guid: ce057e534c95043f9901d01fdc94207e
folderAsset: yes
DefaultImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

View File

@@ -0,0 +1,8 @@
fileFormatVersion: 2
guid: 3823dd185fb194578a096eb7275d43cc
folderAsset: yes
DefaultImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

View File

@@ -0,0 +1,24 @@
{
"name": "Gilzoide.SqliteNet.Tests.Editor",
"rootNamespace": "Gilzoide.SqliteNet.Tests.Editor",
"references": [
"UnityEngine.TestRunner",
"UnityEditor.TestRunner",
"Gilzoide.SqliteNet"
],
"includePlatforms": [
"Editor"
],
"excludePlatforms": [],
"allowUnsafeCode": false,
"overrideReferences": true,
"precompiledReferences": [
"nunit.framework.dll"
],
"autoReferenced": false,
"defineConstraints": [
"UNITY_INCLUDE_TESTS"
],
"versionDefines": [],
"noEngineReferences": false
}

View File

@@ -0,0 +1,7 @@
fileFormatVersion: 2
guid: 116377ddbe6df44f797197063a566aaf
AssemblyDefinitionImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

View File

@@ -0,0 +1,68 @@
/*
* Copyright (c) 2024 Gil Barbosa Reis
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
using NUnit.Framework;
using SQLite;
namespace Gilzoide.SqliteNet.Tests.Editor
{
public class TestSerialization
{
private class Row
{
[PrimaryKey]
public int Id { get; set; }
public int Value { get; set; }
}
[Test, TestCase(100)]
public void TestSQLiteSerialization(int quantity)
{
byte[] serializedDatabase;
using(var db = new SQLiteConnection(""))
{
db.CreateTable<Row>();
for (int i = 0; i < quantity; i++)
{
int added = db.Insert(new Row
{
Id = i,
Value = i,
});
Assert.That(added, Is.EqualTo(1));
}
serializedDatabase = db.Serialize();
}
Assert.That(serializedDatabase, Is.Not.Null);
using(var db = new SQLiteConnection(""))
{
db.Deserialize(serializedDatabase, flags: SQLite3.DeserializeFlags.ReadOnly);
for (int i = 0; i < quantity; i++)
{
Row row = db.Table<Row>().Where(r => r.Id == i).FirstOrDefault();
Assert.That(row, Is.Not.Null, $"Couldn't find row {i}");
Assert.That(row.Id, Is.EqualTo(row.Value));
}
}
}
}
}

View File

@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: e76b1568295e54de09960443991b1a0d
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

View File

@@ -0,0 +1,18 @@
{
"name": "com.gilzoide.sqlite-net",
"displayName": "SQLite-net",
"version": "1.2.4",
"description": "SQLite-net for Unity, supports Windows, Linux, macOS, iOS, tvOS, visionOS, Android and WebGL",
"homepage": "https://github.com/gilzoide/unity-sqlite-net",
"license": "MIT",
"author": {
"name": "Gil Barbosa Reis"
},
"samples": [
{
"displayName": "SQLite REPL",
"description": "Demonstrates a simple REPL for SQL statements.",
"path": "Samples~/REPL"
}
]
}

View File

@@ -0,0 +1,7 @@
fileFormatVersion: 2
guid: a2dcee563e67d4c1b948cbf8bde1afb6
PackageManifestImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant: