​

Ditto SDK 5.1 — Faster Local Queries. More Capable Query Engine.

• Evictions are 53.6× faster and deletes are 43.0× faster on average. This speeds up routine local data clean-up, like clearing the orders from a point-of-sale terminal.
• A full-collection COUNT(*) fell from 149.03 ms to 0.89 ms, which is 167× faster on average. This speeds up badge counts and dashboard totals across an app.

• JOIN combines local collections in a single SELECT, removing the need to run separate queries and merge their results in application code.
• ADVISE looks at a query and tells you the indexes to create to make it faster, all without running it or reading a document.

• If a device is lost or stolen, it’s easier to revoke the device’s certificate, disconnect it from the mesh, and prevent the device from sending or receiving data.
• Revocations travel peer to peer and reach devices even when they can’t see the cloud. Connections from revoked peers are terminated and refused.

• Identifying problems is easier with better tools for analyzing deployed devices, starting with support bundles that capture the device’s effective configuration.
• Corrupted replication metadata is detected and rebuilt automatically, so field issues can be solved without a site visit.

• Multicast allows Ditto to scale to large networks with many edge devices. Edge devices subscribe to a shared group for data sync, which has lower connection cost at scale.
• Opt-in beta capability in the Swift, Kotlin/KMP, Flutter, and Rust SDKs. Support will expand to additional SDKs in the future.

• Upgrading to Ditto SDK 5.1 changes the on-disk index format.
• If you need to downgrade from Ditto SDK 5.1 or later, migrate through Ditto 5.0.2+. You can also migrate through Ditto 4.14.6+.

​

1. Performance: Faster Queries, Lower Memory Use

​

Android retail benchmark

​

Dramatically faster document counts

​

Lower memory use

​

2. Query Engine: New Ditto Query Capabilities

​

Join collections locally

SELECT task._id, task.title, project.name
FROM tasks AS task
JOIN projects AS project ON task.projectId = project._id
WHERE task.status = 'open'

​

Create composite indexes

CREATE INDEX IF NOT EXISTS status_created_idx
ON tasks (status, createdAt DESC)

SELECT * FROM tasks
WHERE status = 'open'
ORDER BY createdAt DESC

​

Find the right indexes with ADVISE

ADVISE SELECT * FROM tasks WHERE estimateHours > 8

{
  "advice": {
    "statement": "select * from tasks where estimateHours > 8",
    "suggestedIndexes": [
      {
        "collection": "tasks",
        "reason": "range predicates on `estimateHours`",
        "statement": "CREATE INDEX IF NOT EXISTS adv_tasks_estimateHours ON default:`tasks` (`estimateHours` ASC)"
      }
    ]
  }
}

​

Return changed documents with RETURNING

UPDATE tasks
SET status = 'done'
WHERE projectId = 'proj-42' AND status = 'open'
RETURNING _id, status

​

Control long-running requests

​

3. Security: Expanded Certificate Revocation

​

4. Troubleshooting: Identify Problems and Recover Automatically

• A configurable Unix debug_socket lets you remotely run DQL diagnostics against an edge device.
  • You can inspect a live device directly rather than reproducing the problem in a lab.
• Nine new network counters under ditto.network.dsoq.* surface Ditto Sync over QUIC (DSOQ) protocol failures in your existing production metrics, without debug logs.
• SQLite metrics distinguish the application data store from replication metadata databases on supported Unix platforms, showing which one is driving disk activity.

​

5. Transport at Scale: Multicast Beta

​

Upgrading to 5.1

​

Tested rollback compatibility

​

Rust-Specific Changes

​

Rust Specific Changelog

• The auth module is now public, exposing DittoAuthenticator, DittoAuthenticationEventHandler, AuthenticationClientFeedback, and get_development_provider(). (#SDKS-3022)
• MulticastBetaConfig and PeerToPeer::multicast_beta for configuring the beta reliable UDP multicast transport. The transport is disabled by default, with availability limited to supported platforms during the beta. On Android and iOS, changes requested while sync is active take effect after sync is stopped and successfully started again, when Ditto validates platform prerequisites. (#SDKS-4471)
• ConnectionType::Multicast enum option representing beta reliable UDP multicast connections. Transport availability is limited to supported platforms during the beta. (#SDKS-4471)

• Added suggested actions to the warning logged when the key in attestation does not match the key reported by transport. (#21402)
• Log lines for update payloads now report chunk_size instead of data to clarify the meaning of the field. (#22102)

• The SortDirection enum in the Store module, a remnant of the legacy v4 Query Builder API. Use DQL ORDER BY clauses instead. (#SDKS-2772)
• The identity module. Use the auth module instead. (#SDKS-3022)

​

DQL for All Data Operations

​

DQL for All Data Operations

​

What Changed

• Legacy query builder removed: All store.collection() methods and fluent query APIs are no longer available
• Full feature parity: Every legacy operation has a DQL equivalent
• Single query language: DQL handles reads, writes, subscriptions, and observers
• Works everywhere: Same syntax across mobile, server, and web
• SQL-familiar: Standard SQL patterns for immediate productivity

​

Why One Query Language

​

Core Improvements

​

Simplified Initialization & Configuration

​

What’s New

• Unified configuration object: All initialization parameters are set through DittoConfig factory methods
• Fallible initialization: Explicit error handling during setup catches configuration issues early
• Asynchronous patterns: Native async/await support where appropriate for each platform
• Simplified authentication: Clearer authorization client that’s easier to understand and implement

​

What This Solves

​

Accessing Configuration at Runtime

// Example: Access database ID
const config = ditto.config;  // or ditto.getConfig() depending on SDK
const databaseID = config.databaseID;

​

Availability

​

Schema-Free Data Modeling

​

What’s New

• Field-level sync: Ditto syncs individual field changes instead of replacing entire objects
• Automatic type inference: No need to pre-define collection schemas or CRDT types
• Nested structures: Insert complex JSON-like documents without type definitions
• Concurrent updates merge: When peers update different fields simultaneously, both changes are preserved

​

What This Solves

• Add-wins behavior on objects: When peers create or modify objects, additions are preserved rather than overwritten
• Field-level delta sync on all nodes: Every field in your document syncs independently, reducing bandwidth and enabling fine-grained conflict resolution throughout the entire document structure

​

New Customers

​

Migrating Customers

ALTER SYSTEM SET DQL_STRICT_MODE = true

​

Migration Considerations

• Data syncs successfully between peers regardless of different strict mode settings
• Each peer interprets data based on its own strict mode setting when reading/writing
• With DQL_STRICT_MODE=false: Objects are inferred as MAPs (field-level merging)
• With DQL_STRICT_MODE=true: Objects without explicit type definitions are treated as REGISTERs (whole object replacement)

• Collections/documents created, modified, or read while strict mode is disabled will use inferred types (objects → MAPs by default)
• Collections/documents created, modified, or read while strict mode is enabled use default REGISTER type and require explicit definitions for other types

• If mixing settings, explicitly define MAP types in collection definitions on peers with strict mode enabled

​

New DQL Query Features

​

CASE Statements

-- Match a field against multiple values
SELECT CASE a
  WHEN 1 THEN 'one'
  WHEN 2 THEN 'two'
  ELSE 'neither'
END
FROM test

-- Use conditional expressions
SELECT CASE
  WHEN a = 1 THEN 'one'
  WHEN a = 2 THEN 'two'
  ELSE 'neither'
END
FROM test

​

BETWEEN Expressions

<expr> BETWEEN <low-expr> AND <high-expr>

SELECT * FROM test WHERE a BETWEEN 1 AND 10

​

Array & Object Search Syntax

(ANY|EVERY|ANY AND EVERY) [name:] value (IN|WITHIN) expression SATISFIES condition END

• IN - Searches the array/object directly
• WITHIN - Searches recursively through nested structures
• ANY - Returns true if at least one element matches
• EVERY - Returns true if all elements match (empty arrays/objects pass)
• ANY AND EVERY - Like EVERY, but empty arrays/objects fail

-- Check if any element in an array equals 2
SELECT ANY x IN [1,2,3] SATISFIES x = 2 END
FROM system:dual

-- Check if any nested element equals 2
SELECT ANY x WITHIN [1,[2],3] SATISFIES x = 2 END
FROM system:dual

-- Check if all elements equal 1 (or are arrays)
SELECT EVERY x WITHIN [1,[1],1]
SATISFIES x = 1 OR type(x) = 'array' END
FROM system:dual

-- Check if any field value equals 2
SELECT ANY x IN {'a':1,'b':2,'c':3} SATISFIES x = 2 END
FROM system:dual

-- Check if any nested field value equals 2
SELECT ANY x WITHIN {'a':1,'b':{'d':2},'c':3} SATISFIES x = 2 END
FROM system:dual

-- Find documents where first array element is less than zero
SELECT * FROM test
WHERE ANY n:v IN test.array_field SATISFIES n = 0 AND v < 0 END

-- Find documents where any nested field is NULL
SELECT * FROM test
WHERE ANY v WITHIN test.details SATISFIES v IS NULL END

-- Find orders where items were modified after order date
SELECT * FROM orders o
WHERE ANY v IN o.items SATISFIES v.modified > o.order_date END

​

Array & Object Transformation Syntax

ARRAY valueExpr FOR [name:] value IN source [WHEN condition] END

OBJECT nameExpr:valueExpr FOR name:value IN source [WHEN condition] END

-- Transform array elements to objects with index
ARRAY {"index":i,"val":v} FOR i:v IN [1,2,3] WHEN v%2 = 0 END
-- Result: [{"index":1,"val":2}]

-- Convert numbers to strings, excluding value 1
ARRAY cast(v,'string') FOR v IN [1,2,3] WHEN v != 1 END
-- Result: ["2","3"]

-- Transform string characters with conditional logic
ARRAY CASE WHEN i%2 = 0 THEN "foo" ELSE "bar" END
FOR i:v IN split("hello","") END
-- Result: ["foo","bar","foo","bar","foo","bar"]

-- Extract values from object into array
ARRAY v FOR n:v IN {"a":"one","b":"two"} END
-- Result: ["one","two"]

-- Transform object keys to uppercase, filter by value length
OBJECT upper(n):v FOR n:v IN {"a":"one","b":"two","c":"three"}
WHEN len(v) = 3 END
-- Result: {"A":"one","B":"two"}

-- Convert array to object with generated field names
OBJECT "field_"||cast(i,"string"):v FOR i:v IN [1,2,3] END
-- Result: {"field_0":1,"field_1":2,"field_2":3}

-- Filter object by value type
OBJECT n:v FOR n:v IN {"a":1,"b":[],"c":2}
WHEN type(v) != 'array' END
-- Result: {"a":1,"c":2}

• If source evaluates to MISSING, the result is MISSING
• For arrays: if source is not an array/object, the result is NULL
• For objects: duplicate field names will overwrite previous values
• Elements/fields where valueExpr evaluates to MISSING are excluded from the result

​

Extended String Literals

-- Use escape sequences in string literals
SELECT * FROM messages
WHERE content = 'Line 1\nLine 2\tTabbed'

-- [PLACEHOLDER: Add more escape sequence examples if needed]

​

Hexadecimal Numeric Constants

-- Use hexadecimal literals
SELECT * FROM config
WHERE flags = 0xFF

-- [PLACEHOLDER: Add more hex literal examples if needed]

​

Performance & Platform

​

DQL Query Performance Improvements

​

Query Planner Enhancements

• Automatic ID scan conversion: Equality filters on _id fields automatically convert to ID scans, bypassing index lookups when exact document IDs are known
• Deferred document fetching: Query planner can defer fetching full documents until after sorting and applying offset/limit when index access supports it
• Improved covering index support: More scenarios where the query planner can satisfy queries entirely from index data without retrieving documents
• Index-only queries: Additional cases where queries can be answered using only index scans

​

Streaming Query Execution

• Reduced memory overhead: Results are streamed rather than fully materialized where possible
• DISTINCT operator streaming: DISTINCT queries now stream results, reducing memory usage for large result sets
• Improved operator inlining: Query operators can be inlined into producers for better performance

​

Shared Statement Cache

• Plan reuse: Compiled query plans are cached and reused for identical or similar statements, eliminating redundant parsing and planning overhead
• Automatic validation: Cached plans are automatically verified and invalidated when collection schemas or system directives change
• Dynamic sizing: The cache automatically resizes based on workload patterns
• Improved large statement performance: Particularly benefits complex queries and larger statements by avoiding expensive re-compilation

​

Data Sync Performance Improvements

​

What’s New

• Tiered blob storage: Smaller sync updates avoid unnecessary disk I/O by using optimized storage tiers
• Improved session handling: Better avoidance of session resets on reconnection when in-flight updates were lost
• Optimized fsync policy: Document sync avoids forcing files to disk by default, decreasing I/O and improving latency

​

Impact

• Faster sync operations: Reduced disk I/O overhead leads to quicker data synchronization
• Lower latency: Optimized file handling decreases sync latency across the board
• Better reconnection handling: Fewer redundant updates after temporary disconnections
• Improved efficiency: Reduced disk operations lower memory and CPU pressure during sync

​

Local System Observability

​

New Virtual Collections

• Query performance metrics and diagnostics in real-time
• Access counters, timers, and other operational metrics via DQL
• Monitor system health and performance without external tools

• Query peer_key, database_id, and configuration settings
• Inspect runtime configuration and system parameters
• Useful for debugging and operational awareness

• Inspect the query plan cache
• View cached statements and their execution plans
• Supports DELETE operations to clear specific cached statements
• Helps optimize query performance and troubleshoot query planning

​

Usage Example

-- Query system information
SELECT * FROM system:system_info

-- View cached query statements
SELECT * FROM system:shared_statements

-- Access metrics
SELECT * FROM system:metrics
WHERE metric_name = 'sync.documents_synced'

-- Clear a specific cached statement
DELETE FROM system:shared_statements
WHERE statement_id = 'abc123'

​

Additional Improvements

​

Reliability & Error Handling

• Enhanced diagnostics: Improved logging when peers receive data that cannot be deserialized
• Recovery mechanisms: Additional recovery paths for document deserialization errors
• Smart log levels: Connection failures start at warning level, escalate to error only after repeated failures
• Panic messages: Filtered to remove internal Rust machinery frames for improved readability

​

Networking Improvements

• Graceful shutdown: Network connections close cleanly when Ditto is stopped
• Faster disconnection detection: When a peer crashes, Ditto stops attempting to connect within 15 seconds (previously up to 75 minutes)
• mDNS improvements: More reliable mDNS discovery, configurable service names, better address filtering
• BLE improvements: Fixed connection issues on Android 9 and earlier devices
• WebSocket BYOD support: Bring Your Own Discovery now supports WebSocket connections
• Connection cleanup: Fixed deadlock where devices could fail to establish new P2P connections until restarted

​

DQL Engine Improvements

• Better error messages: Improved parser error messages for invalid DQL syntax
• Transaction safety: Fixed deadlock scenarios in concurrent transactions
• Index correctness: Fixed issues where index scans could yield incorrect results on document deletion

​

Logging & Diagnostics

• Better disk utilization: On-disk logs resume writing to incomplete files, making better use of available space
• Compressed size limits: Log file limits now apply to compressed size, significantly increasing retention
• Explicit flushing: Logs explicitly flushed before aborting due to panic
• Virtual collections: New system:metrics and system:system_info collections for DQL access to metrics and system information

​

Platform Support

• Linux aarch64: Kotlin SDK now supports ARM64 Linux (Raspberry Pi, AWS Graviton, etc.)
• Swift 6: Full Swift 6 support with Sendable conformance
• 16KB alignment: React Native Android meets Google Play’s November 2025 requirement

​

Upgrading to v5

​

Terminology Updates

​

Database ID (formerly App ID)

• appID → databaseID in all configuration methods
• getAppId() → getConfig().databaseId in SDK APIs
• Portal and documentation updated to use “Database ID” terminology

​

Ditto Server (formerly Ditto Cloud)

• isConnectedToDittoCloud → isConnectedToDittoServer in presence APIs
• Documentation updated to use “Ditto Server” terminology

​

Breaking Changes

​

Removed APIs

​

Legacy Query Builder (All SDKs)

• store.collection() → Use DQL INSERT, UPDATE, EVICT statements
• collection.find() → Use DQL SELECT queries
• collection.findById() → Use DQL with _id filter
• Live queries → Use DQL observers with store.registerObserver()
• Write transactions → Use store.transaction() with DQL

​

Legacy Initialization (All SDKs)

• Identity classes and all subclasses removed
• Ditto(identity:, persistenceDirectory:) constructors removed
• Use DittoConfig factory methods and Ditto.open() instead

​

Sync Methods Moved

• ditto.startSync() → ditto.sync.start()
• ditto.stopSync() → ditto.sync.stop()
• ditto.isSyncActive → ditto.sync.isActive

​

Other Removals

• disableSyncWithV3() - no longer needed, v3 sync removed entirely
• AttachmentToken - use dictionary variant
• Transport diagnostics APIs - obsolete, removed
• Various deprecated presence properties (queryOverlapGroup, meshRole, etc.)
• Emoji log level headings - setting had no effect, removed

​

Behavioral Changes

• DQL strict mode: Now defaults to false - no schema definitions required, automatic CRDT type inference
• String literals in DQL: Double quotes now delimit strings (not identifiers) for JSON compatibility
• Subscription queries: Reject LIMIT and ORDER BY unless DQL_RESTRICT_SUBSCRIPTION=false
• Observer ordering: Observers require explicit ORDER BY clause for stable ordering
• WebSocket sync: Disabled by default in new TransportConfig instances - must explicitly enable
• Document IDs: null is no longer allowed as a document ID

​

SDK Size Reduction

• Smaller application binary sizes
• Reduced memory usage
• Faster SDK initialization
• Simpler maintenance and debugging

​

Rust Migration Guide

• Updating from DittoIdentity to DittoConfig-based initialization
• Replacing legacy query builder operations with DQL statements
• Migrating collection observers to DQL observers
• Updating authentication patterns

​

Rust-Specific Changes

​

API Changes

• Added query_arguments_cbor_data() and query_arguments_json_str() methods to SyncSubscription
• Use these methods to deserialize query arguments into specific types

• Renamed Peer::peer_key_string to Peer::peer_key
• Renamed Connection::peer_key_string1 and Connection::peer_key_string2 to Connection::peer1 and Connection::peer2
• Renamed ConnectionRequest::peer_key_string() to ConnectionRequest::peer_key()
• Renamed is_connected_to_ditto_cloud to is_connected_to_ditto_server

• Added Sync::start() as replacement for Ditto::start_sync()
• Removed Ditto::start_sync() - Use ditto.sync().start() instead
• Added Sync::stop() as replacement for Ditto::stop_sync()
• Removed Ditto::stop_sync() - Use ditto.sync().stop() instead
• Added Sync::is_active() as replacement for Ditto::is_sync_active()
• Removed Ditto::is_sync_active() - Use ditto.sync().is_active() instead

• Removed Store::register_observer() - Use Store::register_observer_v2() instead
• Removed Store::register_observer_with_signal_next() - Use Store::register_observer_v2() instead

• Removed Store::execute() - Use Store::execute_v2() instead
• Removed Store::collection_names() - Use DQL query SELECT * FROM system:collections instead
• Removed Store::disk_usage() - Use Ditto::disk_usage() instead

• Removed Presence::observe() - Use Presence::register_observer() instead
• Removed Presence::exec() - Use Presence::graph() instead

• Removed Ditto::current_transport_config() - Use Ditto::transport_config() instead
• Removed Ditto::root_dir() - Use Ditto::absolute_persistence_directory() instead
• Removed Ditto::data_dir() - Use Ditto::absolute_persistence_directory() instead
• Removed Ditto::authenticator() - Use Ditto::auth() instead
• Removed app_id() and application_id() - Use config().database_id instead

• Removed with_sdk_version() - Use version() instead
• Removed disable_sync_with_v3() - Now disabled by default
• Removed unused identity type “Manual”

• DiskObserverContext renamed to DiskUsageObserver
• DiskUsage::exec() renamed to DiskUsage::item()
• DiskUsageChild renamed to DiskUsageItem

​

Type & Naming Changes

• AppId is now called DatabaseId
• This is the newtype which wraps the UUID string identifying a Ditto database

• Removed SiteId type alias
• Use graph().local_peer.peer_key_string instead

​

Module Reorganization

• auth module from root - Import from identity::auth instead
• ditto module from public exports - Use types from prelude instead
• observer module from public exports - Use specific observer types instead
• subscription module from public exports - Use sync::SyncSubscription instead
• types module from public exports - Use DQL instead

• Observer trait - Use specific observer types returned by register_observer methods
• PresenceObserver struct from legacy API - Use PresenceObserver from Presence::register_observer()

​

Configuration

• Updated to include missing system_parameters field

• Types now define #[serde(default)] for deserializing partial objects

​

Logging

• Added DittoLogger.set_custom_log_callback() for handling Ditto log events with custom callback
• Removed DittoLogger::get_emoji_log_level_headings_enabled() and set_emoji_log_level_headings_enabled()

​

Authentication

• Added development provider method for online playground authentication

​

Migration Example

let config = DittoConfig::new(
    "your-database-id",  // was: app_id
    DittoConfigConnect::Server {
        url: "REPLACE_ME_WITH_YOUR_URL".parse().unwrap(),
    },
);
let ditto = Ditto::open(config).await?;

// Start sync
ditto.sync().start()?;  // was: ditto.start_sync()

let identity = Identity::online_playground(
    "your-app-id",
    "your-token"
)?;
let ditto = Ditto::new(identity, "/path/to/data")?;

ditto.start_sync()?;

​

Accessing Configuration at Runtime

let config = ditto.config();
let database_id = &config.database_id;  // Replaces ditto.app_id() from v4

​

Migration Path

ditto.store().execute(
    "UPDATE cars SET miles = 50000 WHERE _id = 'abc123'"
).await?;

ditto.store().collection("cars")
    .find_by_id("abc123")
    .update(|doc| {
        doc.at("miles").set(50000)?;
        Ok(())
    })?;

ditto.store().register_observer(
    "SELECT * FROM cars WHERE miles > 100000",
    move |result| {
        // handle changes
    }
)?;

ditto.store().collection("cars")
    .find("miles > 100000")
    .observe(move |docs, event| {
        // handle changes
    });

​

How It Works

// Objects are automatically inferred as MAPs - no definition needed
ditto.store().execute(
    r#"
    INSERT INTO products
    DOCUMENTS ({
        _id: '123',
        name: 'Widget',
        metadata: {
            manufacturer: 'Acme Corp',
            warehouse: 'East'
        }
    })
    "#
).await?;

// Query without type definitions
ditto.store().execute("SELECT * FROM products WHERE _id = '123'").await?;

// Must explicitly define MAP types to use objects
ditto.store().execute_v2(
    r#"
    INSERT INTO COLLECTION products (metadata MAP)
    DOCUMENTS ({
        _id: '123',
        name: 'Widget',
        metadata: {
            manufacturer: 'Acme Corp',
            warehouse: 'East'
        }
    })
    "#,
    None
)?;

// Query with explicit MAP definition
ditto.store().execute_v2(
    r#"
    SELECT * FROM COLLECTION products (metadata MAP)
    WHERE _id = '123'
    "#,
    None
)?;

​

Migration

// Database ID
let config = DittoConfig::new(
    "your-database-id",  // was: app_id
    DittoConfigConnect::Server {
        url: "REPLACE_ME_WITH_YOUR_URL".parse().unwrap(),
    },
);

// Presence API
if peer.is_connected_to_ditto_server {
    // handle connection
}

// App ID
let identity = Identity::online_playground(
    "your-app-id",
    "your-token"
)?;

// Presence API
if peer.is_connected_to_ditto_cloud() {
    // handle connection
}

​

Rust Specific Changes

• Updated DittoConfig to include missing system_parameters field in the Rust SDK (#19436)

• Presence graph Peers have renamed the is_connected_to_ditto_cloud property to is_connected_to_ditto_server to clarify that it reflects a connection to any Big Peer rather than specifically those in the Ditto cloud service (#20302)
• AppId is now called DatabaseId. This is the newtype which wraps the UUID string identifying a Ditto database (#20390)
• Renamed Peer::peer_key_string to Peer::peer_key (#SDKS-1185)
• Renamed Connection::peer_key_string1 and Connection::peer_key_string2 to Connection::peer1 and Connection::peer2 (#SDKS-1185)
• Renamed ConnectionRequest::peer_key_string() to ConnectionRequest::peer_key() (#SDKS-1185)
• DiskUsageChild renamed to DiskUsageItem, DiskUsageObserverCtx renamed to DiskUsageObserver, and DiskUsage::exec() renamed to DiskUsage::item(), for consistency with names in other Ditto SDKs and documentation (#SDKS-596)

• query_arguments_cbor_data and query_arguments_json_str methods to SyncSubscription instances. If you want to deserialize query arguments into a specific type, then use these and deserialize things as required (#17003)
• TransportConfig types now define #[serde(default)] to make deserializing transport configs with partial objects work as expected (#20162)
• Ditto log events can be handled with a custom callback using DittoLogger.set_custom_log_callback() (#20239)
• Development provider method for online playground authentication (#20254)
• Sync::stop() as a replacement for Ditto::stop_sync() (#SDKS-2355)
• Sync::start() as a replacement for Ditto::start_sync() (#SDKS-2472)
• Sync::is_active() as a replacement for Ditto::is_sync_active() (#SDKS-2473)
• AwdlConfig and WifiAwareConfig structs to PeerToPeer transport configuration (#SDKS-2952)

• Collection struct. Use DQL statements instead (#17786)
• PendingCursorOperation struct. Use DQL statements instead (#17786)
• PendingIdSpecificOperation struct. Use DQL statements instead (#17786)
• PendingCollectionsOperation struct. Use DQL statements instead (#17786)
• LiveQuery struct. Use Store::register_observer_v2() instead (#17786)
• LiveQueryEvent enum. Use QueryResult from Store::register_observer_v2() instead (#17786)
• LiveQueryMove enum. Use Store::register_observer_v2() instead (#17786)
• SingleDocumentLiveQueryEvent enum. Use Store::register_observer_v2() instead (#17786)
• Subscription type alias. Use SyncSubscription from Sync::register_subscription_v2() instead (#17786)
• DittoDocument trait. Use Document type from Store::execute_v2() instead (#17786)
• DittoMutDocument trait. Use DQL statements with Store::write() instead (#17786)
• DittoCounter struct. Use DQL COUNTER type instead (#17786)
• DittoMutableCounter struct. Use DQL COUNTER type instead (#17786)
• DittoRegister struct. Use DQL REGISTER type instead (#17786)
• DittoMutableRegister struct. Use DQL REGISTER type instead (#17786)
• EventHandler trait. Use callbacks with Store::register_observer_v2() instead (#17786)
• CollectionsEvent enum. Use DQL queries instead (#17786)
• CollectionsEventHandler trait. Use DQL queries instead (#17786)
• SingleDocumentEventHandler trait. Use Store::register_observer_v2() instead (#17786)
• COrderByParam struct. Use ORDER BY in DQL queries instead (#17786)
• QuerySortDirection enum. Use ASC/DESC in DQL queries instead (#17786)
• MutableValue trait. Use DQL statements instead (#17786)
• Store::collection() method. Use DQL statements instead (#17786)
• Store::collections() method. Use DQL queries instead (#17786)
• Store::with_batched_write() method. Use Store::write() instead (#17786)
• Store::queries_hash() method. Use DQL queries instead (#17786)
• Store::queries_hash_mnemonic() method. Use DQL queries instead (#17786)
• Store::register_observer() method. Use Store::register_observer_v2() instead (#17786)
• Store::register_observer_with_signal_next() method. Use Store::register_observer_v2() instead (#17786)
• Store::execute() method. Use Store::execute_v2() instead (#17786)
• Store::collection_names() method. Use DQL query “SELECT * FROM system:collections” instead (#17786)
• Store::disk_usage() method. Use Ditto::disk_usage() instead (#17786)
• Store::start_all_live_query_webhooks() method. Live query webhooks feature has been deprecated (#17786)
• Store::start_live_query_webhook_by_id() method. Live query webhooks feature has been deprecated (#17786)
• Store::register_live_query_webhook() method. Live query webhooks feature has been deprecated (#17786)
• Store::live_query_webhook_generate_new_api_secret() method. Live query webhooks feature has been deprecated (#17786)
• Store::timeseries() method. The experimental timeseries feature has been deprecated (#17786)
• TimeSeries struct. The experimental timeseries feature has been deprecated (#17786)
• WriteStrategy enum. Use DQL INSERT statements instead (#17786)
• Presence::observe() method. Use Presence::register_observer() instead (#17786)
• Presence::exec() method. Use Presence::graph() instead (#17786)
• PresenceObserver struct from legacy API. Use PresenceObserver from Presence::register_observer() instead (#17786)
• Ditto::current_transport_config() method. Use Ditto::transport_config() instead (#17786)
• Ditto::root_dir() method. Use Ditto::absolute_persistence_directory() instead (#17786)
• Ditto::data_dir() method. Use Ditto::absolute_persistence_directory() instead (#17786)
• Ditto::authenticator() method. Use Ditto::auth() instead (#17786)
• SiteId type alias. Use graph().local_peer.peer_key_string instead (#17786)
• TransportDiagnostics struct. This unimplemented feature has been removed (#17786)
• Observer trait. Use specific observer types returned by register_observer methods instead (#17786)
• auth module from root. Import from identity::auth instead (#17786)
• ditto module from public exports. Use types from prelude instead (#17786)
• observer module from public exports. Use specific observer types instead (#17786)
• subscription module from public exports. Use sync::SyncSubscription instead (#17786)
• types module from public exports. Use DQL instead (#17786)
• Unused identity type “Manual” has been removed (#20257)
• Ditto struct no longer has app_id() or application_id() functions. Use config().database_id instead (#20259)
• with_sdk_version() method and replaced with version() method (#20298)
• disable_sync_with_v3() API. This is now disabled by default (#20325)
• Ditto::stop_sync(). Use ditto.sync().stop() instead (#SDKS-2355)
• Ditto::start_sync(). Use ditto.sync().start() instead (#SDKS-2472)
• Ditto::is_sync_active(). Use ditto.sync().is_active() instead (#SDKS-2473)
• DittoLogger::get_emoji_log_level_headings_enabled() and DittoLogger::set_emoji_log_level_headings_enabled() methods (#SDKS-2604)
• DittoAuthenticator::login_with_token_and_feedback() method. Use DittoAuthenticator::login() instead (#SDKS-2589)
• DittoBuilder struct. Use Ditto::open() or Ditto::open_sync() with DittoConfig for initialization instead (#SDKS-2589)
• Ditto::builder() method. Use Ditto::open() or Ditto::open_sync() with DittoConfig instead (#SDKS-2589)
• Ditto::get_logging_enabled() method. Use DittoLogger::get_logging_enabled() instead (#SDKS-2589)
• Ditto::get_minimum_log_level() method. Use DittoLogger::get_minimum_log_level() instead (#SDKS-2589)
• Ditto::persistence_directory() method. Use DittoConfig to obtain persistence directory configuration (#SDKS-2589)
• Ditto::set_logging_enabled() method. Use DittoLogger::set_logging_enabled() instead (#SDKS-2589)
• Ditto::set_minimum_log_level() method. Use DittoLogger::set_minimum_log_level() instead (#SDKS-2589)
• ErrorKind::as_str() method. Use the Display implementation for ErrorKind instead (#SDKS-2589)
• Identity trait and all concrete implementations (OnlineWithAuthentication, OnlinePlayground, OfflinePlayground, SharedKey). Use DittoConfig for all initialization scenarios instead (#SDKS-2589)
• Observer trait. Use drop(observer) to stop an observer (#SDKS-2589)