sqlce 0.1.0__tar.gz

sqlce-0.1.0/.github/workflows/release.yml

@@ -0,0 +1,78 @@
+name: Build and publish
+
+on:
+  push:
+    tags:
+      - "v*"
+
+jobs:
+  build-linux:
+    name: Build wheel (Linux)
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Build wheels
+        uses: pypa/cibuildwheel@v2.21.3
+        env:
+          CIBW_ARCHS_LINUX: x86_64
+          CIBW_BUILD_VERBOSITY: 1
+
+      - name: Build sdist
+        run: |
+          python -m pip install --upgrade pip build
+          python -m build --sdist
+
+      - name: Collect wheels and sdist into one flat folder
+        run: |
+          mkdir -p collected
+          cp wheelhouse/*.whl collected/
+          cp dist/*.tar.gz collected/
+
+      - uses: actions/upload-artifact@v4
+        with:
+          name: dist-linux
+          path: collected/*
+
+  build-windows:
+    name: Build wheel (Windows)
+    runs-on: windows-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.11"
+
+      - name: Install build tools
+        run: |
+          python -m pip install --upgrade pip
+          pip install build
+
+      - name: Build wheel
+        run: |
+          python -m build --wheel -C cmake.args="-DSDF_BUILD_PYTHON_BINDINGS=ON"
+
+      - uses: actions/upload-artifact@v4
+        with:
+          name: dist-windows
+          path: dist/*
+
+  publish:
+    name: Publish to PyPI
+    needs: [build-linux, build-windows]
+    runs-on: ubuntu-latest
+    environment: pypi
+    permissions:
+      id-token: write
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          pattern: dist-*
+          path: dist
+          merge-multiple: true
+
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          packages-dir: dist

sqlce-0.1.0/.gitignore

@@ -0,0 +1,95 @@
+*.d
+
+*.slo
+*.lo
+*.o
+*.obj
+
+*.gch
+*.pch
+
+*.ilk
+*.pdb
+
+*.so
+*.so.*
+*.dylib
+*.dll
+
+*.mod
+*.smod
+
+*.lai
+*.la
+*.a
+*.lib
+
+*.exe
+*.out
+*.app
+
+build/
+Build/
+build-*/
+cmake-build-debug/
+cmake-build-release/
+CMakeFiles/
+CMakeCache.txt
+cmake_install.cmake
+Makefile
+install_manifest.txt
+compile_commands.json
+vcpkg_installed/
+Testing/
+.cache/
+
+.idea/
+.vscode/
+
+.venv/
+venv/
+env/
+ENV/
+
+__pycache__/
+*.pyo
+*.pyd
+*.egg
+*.egg-info/
+dist/
+
+*.dwo
+
+.pytest_cache/
+coverage.xml
+.coverage
+htmlcov/
+
+*.tmp
+*.log
+*.bak
+*.swp
+
+raw/
+images/
+sessions/
+downloads/
+
+*.tar.gz
+*.zip
+*.whl
+
+*.bat
+*.jpg
+*.png
+*.json
+
+!/assets/*.jpg
+!/assets/*.png
+
+.DS_Store
+Thumbs.db
+cookies.txt
+
+.env
+.env.local

sqlce-0.1.0/CMakeLists.txt

@@ -0,0 +1,9 @@
+cmake_minimum_required(VERSION 3.20)
+project(sqlce_workspace LANGUAGES CXX)
+
+option(SDF_BUILD_PYTHON_BINDINGS "Build the _sdf_native pybind11 extension module" OFF)
+add_subdirectory(core)
+
+if(SDF_BUILD_PYTHON_BINDINGS)
+    add_subdirectory(bindings)
+endif()

sqlce-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 boykopovar
+
+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.

sqlce-0.1.0/PKG-INFO

@@ -0,0 +1,47 @@
+Metadata-Version: 2.2
+Name: sqlce
+Version: 0.1.0
+Summary: Cross-platform lib for reading SQL Server CE (.sdf)
+Author-Email: boykopovar <boykopovar@gmail.com>
+License: MIT
+Classifier: Development Status :: 4 - Beta
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: C++
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Project-URL: Homepage, https://github.com/boykopovar/sqlce
+Project-URL: Issues, https://github.com/boykopovar/sqlce/issues
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+# sqlce
+
+Реверс-инжиниринг бинарного формата `.sdf` (SQL Server Compact Edition 4.0).
+ 
+Анализ внутреннего устройства формата по декомпилированным компонентам SQL CE. Цель - предоставить кроссплатформенную и независимую от рантайма реализацию чтения `.sdf` и документацию формата.
+
+## Структура
+
+- `core/` - реализация парсера на C++
+- `bindings/` - Биндинги для C++ библиотеки к другим языкам
+- `python/sqlce/` - Python API
+- `research/` - Экспериментальные скрипты
+
+## Установка
+
+```bash
+pip install sqlce
+```
+
+[Документирование формата](docs/4.0/ru/00-overview.md)
+
+Текущая [реализация](main.py) поддерживает чтение списка таблиц, структуры таблиц, содержимого записей. Использует c++.
+
+[Соглашения по написанию кода](docs/CONVENTIONS.md)

sqlce-0.1.0/README.md

@@ -0,0 +1,24 @@
+# sqlce
+
+Реверс-инжиниринг бинарного формата `.sdf` (SQL Server Compact Edition 4.0).
+ 
+Анализ внутреннего устройства формата по декомпилированным компонентам SQL CE. Цель - предоставить кроссплатформенную и независимую от рантайма реализацию чтения `.sdf` и документацию формата.
+
+## Структура
+
+- `core/` - реализация парсера на C++
+- `bindings/` - Биндинги для C++ библиотеки к другим языкам
+- `python/sqlce/` - Python API
+- `research/` - Экспериментальные скрипты
+
+## Установка
+
+```bash
+pip install sqlce
+```
+
+[Документирование формата](docs/4.0/ru/00-overview.md)
+
+Текущая [реализация](main.py) поддерживает чтение списка таблиц, структуры таблиц, содержимого записей. Использует c++.
+
+[Соглашения по написанию кода](docs/CONVENTIONS.md)

sqlce-0.1.0/bindings/CMakeLists.txt

@@ -0,0 +1,27 @@
+if(POLICY CMP0148)
+    cmake_policy(SET CMP0148 NEW)
+endif()
+
+find_package(pybind11 CONFIG REQUIRED)
+pybind11_add_module(_sdf_native
+        src/module.cpp
+        src/value_convert.cpp
+)
+
+target_compile_features(_sdf_native PRIVATE cxx_std_20)
+set_target_properties(_sdf_native PROPERTIES CXX_STANDARD 20 CXX_STANDARD_REQUIRED ON CXX_EXTENSIONS OFF)
+
+target_link_libraries(_sdf_native PRIVATE libsdf)
+
+if(MINGW)
+    target_link_options(_sdf_native PRIVATE -static-libgcc -static-libstdc++ -static -lwinpthread)
+endif()
+
+if(MSVC)
+    target_compile_options(_sdf_native PRIVATE /W4 /utf-8 /permissive-)
+    target_compile_definitions(_sdf_native PRIVATE NOMINMAX _CRT_SECURE_NO_WARNINGS)
+else()
+    target_compile_options(_sdf_native PRIVATE -Wall -Wextra)
+endif()
+
+install(TARGETS _sdf_native LIBRARY DESTINATION sqlce)

sqlce-0.1.0/bindings/src/module.cpp

@@ -0,0 +1,115 @@
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+
+#include <cstdint>
+#include <optional>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "sdf/application/ColumnSchema.hpp"
+#include "sdf/application/SdfDatabase.hpp"
+#include "sdf/domain/Row.hpp"
+
+#include "value_convert.hpp"
+
+namespace sdf::bindings
+{
+
+namespace py = pybind11;
+
+namespace
+{
+
+constexpr char ModuleDoc[] = "Native reader for SQL Server Compact (.sdf) database files.";
+
+constexpr char DatabaseClassName[] = "SdfDatabase";
+constexpr char DatabaseDoc[] = "Reads tables, schemas and rows from a .sdf database file.";
+constexpr char InitDoc[] = "Open a .sdf file at the given path.";
+constexpr char PathArgName[] = "path";
+constexpr char ListTablesName[] = "list_tables";
+constexpr char ListTablesDoc[] = "Return the names of all tables in the database.";
+constexpr char TableSchemaName[] = "table_schema";
+constexpr char TableSchemaDoc[] = "Return the column schema of a table.";
+constexpr char ReadTableName[] = "read_table";
+constexpr char ReadTableDoc[] = "Return every row of a table as a list of column-name -> value mappings.";
+constexpr char TableNameArgName[] = "table_name";
+
+constexpr char SchemaClassName[] = "ColumnSchema";
+constexpr char SchemaDoc[] = "Describes a single column of a table.";
+constexpr char OrdinalAttrName[] = "ordinal";
+constexpr char NameAttrName[] = "name";
+constexpr char TypeNameAttrName[] = "type_name";
+constexpr char DeclaredSizeAttrName[] = "declared_size";
+constexpr char PrecisionAttrName[] = "precision";
+constexpr char ScaleAttrName[] = "scale";
+
+py::dict RowToDict(const domain::Row& row)
+{
+    py::dict result;
+    for (const auto& [columnName, value] : row.Values())
+    {
+        result[py::str(columnName)] = ToPyObject(value);
+    }
+    return result;
+}
+
+std::vector<py::dict> ReadTableAsDicts(const application::SdfDatabase& database, const std::string& tableName)
+{
+    std::vector<py::dict> result;
+    const std::vector<domain::Row> rows = database.ReadTable(tableName);
+    result.reserve(rows.size());
+    for (const domain::Row& row : rows)
+    {
+        result.push_back(RowToDict(row));
+    }
+    return result;
+}
+
+std::optional<int> OptionalByteToInt(std::optional<std::uint8_t> value)
+{
+    if (!value.has_value())
+    {
+        return std::nullopt;
+    }
+    return static_cast<int>(*value);
+}
+
+}
+
+PYBIND11_MODULE(_sdf_native, module)
+{
+    module.doc() = ModuleDoc;
+
+    py::class_<application::ColumnSchema>(module, SchemaClassName, SchemaDoc)
+        .def_property_readonly(
+            OrdinalAttrName,
+            [](const application::ColumnSchema& schema) { return schema.ordinal; })
+        .def_property_readonly(
+            NameAttrName,
+            [](const application::ColumnSchema& schema) { return schema.name; })
+        .def_property_readonly(
+            TypeNameAttrName,
+            [](const application::ColumnSchema& schema) { return std::string(schema.typeName); })
+        .def_property_readonly(
+            DeclaredSizeAttrName,
+            [](const application::ColumnSchema& schema) { return schema.declaredSize; })
+        .def_property_readonly(
+            PrecisionAttrName,
+            [](const application::ColumnSchema& schema) { return OptionalByteToInt(schema.precision); })
+        .def_property_readonly(
+            ScaleAttrName,
+            [](const application::ColumnSchema& schema) { return OptionalByteToInt(schema.scale); });
+
+    py::class_<application::SdfDatabase>(module, DatabaseClassName, DatabaseDoc)
+        .def(py::init<const std::string&>(), py::arg(PathArgName), InitDoc)
+        .def(ListTablesName, &application::SdfDatabase::ListTables, ListTablesDoc)
+        .def(
+            TableSchemaName,
+            &application::SdfDatabase::TableSchema,
+            py::arg(TableNameArgName),
+            TableSchemaDoc)
+        .def(ReadTableName, &ReadTableAsDicts, py::arg(TableNameArgName), ReadTableDoc);
+}
+
+}

sqlce-0.1.0/bindings/src/value_convert.cpp

@@ -0,0 +1,146 @@
+#include "value_convert.hpp"
+
+#include <pybind11/stl.h>
+
+#include <array>
+#include <cstdint>
+#include <string>
+#include <variant>
+#include <vector>
+
+#include "sdf/domain/DateTimeValue.hpp"
+#include "sdf/domain/Guid.hpp"
+#include "sdf/domain/NumericValue.hpp"
+
+namespace sdf::bindings
+{
+
+namespace py = pybind11;
+
+namespace
+{
+
+constexpr char DatetimeModuleName[] = "datetime";
+constexpr char DatetimeClassName[] = "datetime";
+constexpr char DecimalModuleName[] = "decimal";
+constexpr char DecimalClassName[] = "Decimal";
+constexpr char UuidModuleName[] = "uuid";
+constexpr char UuidClassName[] = "UUID";
+constexpr char BytesLeArgName[] = "bytes_le";
+constexpr std::uint32_t MicrosecondsPerMillisecond = 1000;
+constexpr std::uint32_t MillisecondsPerSecond = 1000;
+constexpr std::uint32_t SecondsPerMinute = 60;
+constexpr std::uint32_t MinutesPerHour = 60;
+constexpr std::uint32_t HoursPerDay = 24;
+
+py::object ImportAttr(const char* moduleName, const char* attrName)
+{
+    return py::module_::import(moduleName).attr(attrName);
+}
+
+py::tuple DigitsToTuple(const std::string& digits)
+{
+    py::tuple result(digits.size());
+    for (std::size_t i = 0; i < digits.size(); ++i)
+    {
+        result[i] = py::int_(digits[i] - '0');
+    }
+    return result;
+}
+
+py::object DateTimeFromValue(const domain::DateTimeValue& value)
+{
+    static const py::object datetimeClass = ImportAttr(DatetimeModuleName, DatetimeClassName);
+
+    const domain::CalendarDate date = value.Date();
+    const std::uint32_t totalSeconds = value.MillisecondsSinceMidnight() / MillisecondsPerSecond;
+    const std::uint32_t microsecond =
+        (value.MillisecondsSinceMidnight() % MillisecondsPerSecond) * MicrosecondsPerMillisecond;
+    const std::uint32_t hour = (totalSeconds / (SecondsPerMinute * MinutesPerHour)) % HoursPerDay;
+    const std::uint32_t minute = (totalSeconds / SecondsPerMinute) % MinutesPerHour;
+    const std::uint32_t second = totalSeconds % SecondsPerMinute;
+
+    return datetimeClass(date.year, date.month, date.day, hour, minute, second, microsecond);
+}
+
+py::object DecimalFromValue(const domain::NumericValue& value)
+{
+    static const py::object decimalClass = ImportAttr(DecimalModuleName, DecimalClassName);
+
+    const int sign = value.IsPositive() ? 0 : 1;
+    const py::tuple digits = DigitsToTuple(value.UnscaledDigits());
+    const int exponent = -static_cast<int>(value.Scale());
+
+    return decimalClass(py::make_tuple(sign, digits, exponent));
+}
+
+py::object UuidFromValue(const domain::Guid& value)
+{
+    static const py::object uuidClass = ImportAttr(UuidModuleName, UuidClassName);
+
+    const std::array<std::uint8_t, 16>& bytes = value.Bytes();
+    py::bytes bytesLe(reinterpret_cast<const char*>(bytes.data()), bytes.size());
+    return uuidClass(py::arg(BytesLeArgName) = bytesLe);
+}
+
+struct ValueVisitor
+{
+    py::object operator()(const domain::NullValue&) const
+    {
+        return py::none();
+    }
+
+    py::object operator()(std::int64_t value) const
+    {
+        return py::int_(value);
+    }
+
+    py::object operator()(std::uint64_t value) const
+    {
+        return py::int_(value);
+    }
+
+    py::object operator()(double value) const
+    {
+        return py::float_(value);
+    }
+
+    py::object operator()(bool value) const
+    {
+        return py::bool_(value);
+    }
+
+    py::object operator()(const std::string& value) const
+    {
+        return py::str(value);
+    }
+
+    py::object operator()(const std::vector<std::uint8_t>& value) const
+    {
+        return py::bytes(reinterpret_cast<const char*>(value.data()), value.size());
+    }
+
+    py::object operator()(const domain::DateTimeValue& value) const
+    {
+        return DateTimeFromValue(value);
+    }
+
+    py::object operator()(const domain::NumericValue& value) const
+    {
+        return DecimalFromValue(value);
+    }
+
+    py::object operator()(const domain::Guid& value) const
+    {
+        return UuidFromValue(value);
+    }
+};
+
+}
+
+py::object ToPyObject(const domain::ColumnValue& value)
+{
+    return std::visit(ValueVisitor{}, value.Storage());
+}
+
+}

sqlce-0.1.0/bindings/src/value_convert.hpp

@@ -0,0 +1,15 @@
+#ifndef SDF_BINDINGS_VALUE_CONVERT_HPP
+#define SDF_BINDINGS_VALUE_CONVERT_HPP
+
+#include <pybind11/pybind11.h>
+
+#include "sdf/domain/ColumnValue.hpp"
+
+namespace sdf::bindings
+{
+
+pybind11::object ToPyObject(const domain::ColumnValue& value);
+
+}
+
+#endif

sqlce-0.1.0/core/CMakeLists.txt

@@ -0,0 +1,60 @@
+cmake_minimum_required(VERSION 3.20)
+project(libsdf LANGUAGES CXX)
+
+set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_CXX_EXTENSIONS OFF)
+
+if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
+    set(CMAKE_BUILD_TYPE "Release" CACHE STRING "Build type" FORCE)
+endif()
+
+add_library(libsdf
+        src/domain/ColumnDef.cpp
+        src/domain/ColumnType.cpp
+        src/domain/ColumnValue.cpp
+        src/domain/DateTimeValue.cpp
+        src/domain/Guid.cpp
+        src/domain/NumericValue.cpp
+        src/domain/Row.cpp
+        src/domain/TableDef.cpp
+        src/infrastructure/BinaryReader.cpp
+        src/infrastructure/FileStorage.cpp
+        src/infrastructure/PageView.cpp
+        src/parsing/CatalogPageScanner.cpp
+        src/parsing/CatalogRow.cpp
+        src/parsing/CatalogRowDecoder.cpp
+        src/parsing/CatalogSchema.cpp
+        src/parsing/LobChainRegistry.cpp
+        src/parsing/RowDecoder.cpp
+        src/parsing/TableCatalogBuilder.cpp
+        src/parsing/TextDecoder.cpp
+        src/application/SdfDatabase.cpp
+)
+
+set_target_properties(libsdf PROPERTIES PREFIX "" OUTPUT_NAME "libsdf" POSITION_INDEPENDENT_CODE ON)
+
+target_include_directories(libsdf PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/include)
+
+if(MSVC)
+    target_compile_options(libsdf PRIVATE /W4 /utf-8 /permissive-)
+    target_compile_definitions(libsdf PRIVATE NOMINMAX _CRT_SECURE_NO_WARNINGS)
+elseif(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+    target_compile_options(libsdf PRIVATE -Wall -Wextra -Wno-free-nonheap-object)
+else()
+    target_compile_options(libsdf PRIVATE -Wall -Wextra)
+endif()
+
+add_executable(sdf_dump app/main.cpp)
+target_link_libraries(sdf_dump PRIVATE libsdf)
+
+if(MSVC)
+    target_compile_options(sdf_dump PRIVATE /W4 /utf-8 /permissive-)
+    target_compile_definitions(sdf_dump PRIVATE NOMINMAX _CRT_SECURE_NO_WARNINGS)
+else()
+    target_compile_options(sdf_dump PRIVATE -Wall -Wextra)
+endif()
+
+enable_testing()
+
+add_subdirectory(tests)