SQLiteNow

https://mobiletoly.github.io/sqlitenow-kmp/
Admin
SQLiteNow is a type-safe SQL database framework for Kotlin Multiplatform and Flutter/Dart that...
Tokens:40,392
Snippets:531
Trust Score:9.7
Update:5 months ago
Show doc for...
Tokens:
Raw
### Example SQL Initialization Data

Source: https://mobiletoly.github.io/sqlitenow-kmp/flutter/sql-reference/initialize-data

This example demonstrates how to insert initial data into the 'task' table. Ensure that the data format, especially for timestamps, matches your schema requirements.

```sql
INSERT INTO task (id, title, completed, created_at)
VALUES (1, 'Review schedule', 0, '2026-01-01T09:00:00Z');

INSERT INTO task (id, title, completed, created_at)
VALUES (2, 'Prepare visit notes', 0, '2026-01-01T10:00:00Z');
```

--------------------------------

### Valid Migration File Name Examples

Source: https://mobiletoly.github.io/sqlitenow-kmp/flutter/migrations

Illustrates the correct naming conventions for migration SQL files.

```plaintext
0001.sql
0002_add_due_date.sql
0010_create_indexes.sql

```

--------------------------------

### Example Migration File 0002.sql

Source: https://mobiletoly.github.io/sqlitenow-kmp/documentation/migration

Contains SQL statements to migrate from version 1 to version 2, creating a 'user_preferences' table with foreign key constraints.

```sql
-- Migration from version 1 to version 2
CREATE TABLE user_preferences
(
    id      INTEGER PRIMARY KEY NOT NULL,
    user_id INTEGER             NOT NULL,
    theme   TEXT                NOT NULL DEFAULT 'light',
    FOREIGN KEY (user_id)       REFERENCES person (id)
);

```

--------------------------------

### Initial Schema Definition

Source: https://mobiletoly.github.io/sqlitenow-kmp/flutter/migrations

Defines the starting schema for version 1 of your database, used for fresh installations.

```sql
CREATE TABLE task (
  id INTEGER PRIMARY KEY NOT NULL,
  title TEXT NOT NULL,
  completed INTEGER NOT NULL
);

```

--------------------------------

### Setup Android App Context

Source: https://mobiletoly.github.io/sqlitenow-kmp/tutorials/part-3-reactive-ui

Required for Android to initialize the database path helper. Call this in your main activity's onCreate method before setting the content.

```kotlin
class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        enableEdgeToEdge()
        super.onCreate(savedInstanceState)

        setupAndroidAppContext(applicationContext)
        setContent { App() }
    }
}
```

--------------------------------

### Init SQL for Seed Data

Source: https://mobiletoly.github.io/sqlitenow-kmp/flutter/migrations

Provides seed data for new database installations, such as default lookup values.

```sql
INSERT INTO task_label(id, name) VALUES (1, 'Inbox');

```

--------------------------------

### Invalid Migration File Name Examples

Source: https://mobiletoly.github.io/sqlitenow-kmp/flutter/migrations

Shows examples of incorrect migration file naming that will cause generation to fail.

```plaintext
1.sql
001.sql
v001.sql
add_due_date.sql

```

--------------------------------

### Example Migration File 0001.sql

Source: https://mobiletoly.github.io/sqlitenow-kmp/documentation/migration

Contains SQL statements to migrate from version 0 to version 1, adding a 'middle_name' column and an index to the 'Person' table.

```sql
-- Migration from version 0 (initial version) to version 1
ALTER TABLE Person
    ADD COLUMN middle_name TEXT;
CREATE INDEX idx_person_middle_name ON Person (middle_name);

```

--------------------------------

### Initialize Database with Custom Adapters

Source: https://mobiletoly.github.io/sqlitenow-kmp/kmp/recipes/serialization

When initializing your database, provide custom adapter functions for each field that requires special serialization. This example demonstrates how to set up `sqlColumnToTags` for decoding from SQLite and `tagsToSqlColumn` for encoding to SQLite, using JSON encoding/decoding.

```kotlin
val db = AppDatabase(
    dbName = dbPath,
    migration = VersionBasedDatabaseMigrations(),
    taskAdapters = AppDatabase.TaskAdapters(
        sqlColumnToTags = { value -> value.jsonDecodeFromSqlite() },
        tagsToSqlite = { tags -> tags.jsonEncodeToSqlite() },
    ),
)

```

--------------------------------

### Setup Android App Context

Source: https://mobiletoly.github.io/sqlitenow-kmp/getting-started

Provide the Android application context to the SQLiteNow framework. This is necessary for platform-specific features like resolving database paths on Android.

```kotlin
class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        
        // Add this call to provide android context to SQLiteNow framework
        setupAndroidAppContext(this.applicationContext)

        // Rest of your initialization code...
    }
}


```

--------------------------------

### Generated AppDatabase Class Structure

Source: https://mobiletoly.github.io/sqlitenow-kmp/flutter/getting-started

This is an example of the structure of the generated `AppDatabase` class, showing its constructor and methods.

```dart
final class AppDatabase {
  AppDatabase({required String path, required AppDatabaseAdapters adapters});
  AppDatabase.inMemory({required AppDatabaseAdapters adapters});

  Future<void> open();
  Future<void> close();
  Future<T> transaction<T>(Future<T> Function() block);

  late final TaskQueries task;
}

```

--------------------------------

### Run Flutter Tests

Source: https://mobiletoly.github.io/sqlitenow-kmp/flutter/example

Execute unit and integration tests for the Flutter todo example. Ensure an Android emulator or iOS simulator is running for integration tests.

```bash
flutter test

```

```bash
flutter test integration_test -d <device-id>

```

--------------------------------

### Create Mood Database Factory

Source: https://mobiletoly.github.io/sqlitenow-kmp/tutorials/part-1-bootstrap

Implement a factory class to create and open the MoodTrackerDatabase instance. It handles database path resolution and migration setup.

```kotlin
class MoodDatabaseFactory(
    private val dbName: String = "mood_tracker.db",
    private val debug: Boolean = false,
) {
    suspend fun create(): MoodTrackerDatabase {
        val appName = "MoodTracker"
        val resolvedName = resolveDatabasePath(dbName = dbName, appName = appName)
        val database = MoodTrackerDatabase(
            dbName = resolvedName,
            migration = VersionBasedDatabaseMigrations(),
            debug = debug,
        )
        database.open()
        return database
    }
}

```

--------------------------------

### Open Local Runtime State

Source: https://mobiletoly.github.io/sqlitenow-kmp/sync/open-connect-rebuild

Use `open()` to prepare local runtime state, validate metadata, install triggers, and restore or create the internal source identity. This operation is local-only and does not communicate with the server.

```kotlin
client.open().getOrThrow()

```

--------------------------------

### Execute SELECT Query as Flow

Source: https://mobiletoly.github.io/sqlitenow-kmp/documentation/query-data

Demonstrates executing a SELECT query using the `asFlow()` method to get a reactive Flow. The Flow re-executes the query when relevant tables change.

```kotlin
db.person
    .selectAll(PersonQuery.SelectAll.Params(limit = -1, offset = 0))
    .asFlow()
    .collect { persons ->
        println("Persons updated: ${persons.size}")
        updateUI(persons)
    }

```

--------------------------------

### Insert a New Task

Source: https://mobiletoly.github.io/sqlitenow-kmp/flutter/getting-started

Example of using the generated `insertOne` method to add a new task to the database.

```dart
await db.task.insertOne(
  const TaskInsertOneParams(
    id: 1,
    title: 'Write SQL',
    priority: 'HIGH',
    completed: 0,
  ),
);

```

--------------------------------

### Generated SELECT ALL Query Object

Source: https://mobiletoly.github.io/sqlitenow-kmp/documentation/query-data

Example of the generated Kotlin object for a SELECT ALL query, including data classes for parameters and results.

```kotlin
object PersonQuery {
    object SelectAll {
        data class Params(
            val limit: Long,
            val offset: Long
        )

        data class Result(
            val id: Long,
            val firstName: String,
            val lastName: String,
            val email: String,
            val userPhone: String?,
            val birthDate: kotlinx.datetime.LocalDate?,
            val createdAt: kotlin.time.Instant,
        )
        
        // ...
    }
}

```

--------------------------------

### Configure Enum Adapters

Source: https://mobiletoly.github.io/sqlitenow-kmp/recipes/serialization

Configure adapters to map between the enum's stable string value and its persisted representation in the database. This example uses `AddressType`.

```kotlin
val db = SampleDatabase(
    dbName = resolveDatabasePath(dbName = "sample.db", appName = "SampleApp"),
    migration = VersionBasedDatabaseMigrations(),
    personAddressAdapters = SampleDatabase.PersonAddressAdapters(
        addressTypeToSqlColumn = { it.value },
        sqlColumnToAddressType = { value -> AddressType.from(value) },
    )
)

```

--------------------------------

### Generated Task Namespace Methods

Source: https://mobiletoly.github.io/sqlitenow-kmp/flutter/getting-started

Example of methods generated for the 'task' namespace, including insert, update, and select operations.

```dart
Future<void> insertOne(TaskInsertOneParams params);
Future<void> completeById(TaskCompleteByIdParams params);
SelectRunner<TaskRow> selectAll();

```

--------------------------------

### Generated SELECT by ID Query Object

Source: https://mobiletoly.github.io/sqlitenow-kmp/documentation/query-data

Example of the generated Kotlin object for a SELECT by ID query, including data classes for parameters and results.

```kotlin
object PersonQuery {
    object SelectById {
        data class Params(
            val id: Long
        )

        data class Result(
            val id: Long,
            val firstName: String,
            val lastName: String,
            val email: String,
            val userPhone: String?,
            val birthDate: kotlinx.datetime.LocalDate?,
            val createdAt: kotlin.time.Instant,
        )
        
        // ...
    }
}

```

--------------------------------

### Typical Logout Flow

Source: https://mobiletoly.github.io/sqlitenow-kmp/sync/open-connect-rebuild

Execute `syncThenDetach()` for a typical logout flow. If it fails, the UI should stop new writes or keep the user attached. A successful `syncThenDetach()` ensures the next signed-in session starts with a fresh Oversqlite source stream.

```kotlin
val result = client.syncThenDetach().getOrThrow()
if (!result.isSuccess()) {
    // Ask the UI to stop producing new writes or keep the user attached.
}

```

--------------------------------

### Initialize Sample Database

Source: https://mobiletoly.github.io/sqlitenow-kmp/getting-started

Initialize the database instance, providing a name, adapters for custom type conversions (e.g., dates), and migration strategies.

```kotlin
// Initialize your database
// Normally you want to find a better place for this code, but for the sake of example it's here
val db = SampleDatabase(
    resolveDatabasePath(dbName = "sample.db", appName = "SampleApp"),
    personAdapters = SampleDatabase.PersonAdapters(
        // serialize LocalDate to SQLite date string for `birth_date` column
        birthDateToSqlColumn = {
            it?.toSqliteDate()
        },
        // deserialize SQLite date string to LocalDate for `birth_date` column
        sqlColumnToBirthDate = {
            it?.let { LocalDate.fromSqliteDate(it) }
        },
        // deserialize RFC3339 text to Instant for `created_at` column
        sqlColumnToCreatedAt = {
            Instant.fromRfc3339String(it)
        },
        // serialize Instant back to RFC3339 text for `created_at` column
        createdAtToSqlColumn = {
            it.toRfc3339String()
        },
    ),
    migration = VersionBasedDatabaseMigrations()
)


```

--------------------------------

### Typical Application Flow

Source: https://mobiletoly.github.io/sqlitenow-kmp/sync/open-connect-rebuild

This flow demonstrates opening the client, attaching the user if available, and then syncing. It covers the common scenario of initializing the client and handling authenticated sessions.

```kotlin
client.open().getOrThrow()

if (currentUserId != null) {
    when (val attach = client.attach(currentUserId).getOrThrow()) {
        is AttachResult.Connected -> client.sync().getOrThrow()
        is AttachResult.RetryLater -> Unit
    }
}

```

--------------------------------

### Perform Transaction

Source: https://mobiletoly.github.io/sqlitenow-kmp/flutter/getting-started

Example of executing multiple database operations within a single transaction to ensure atomicity.

```dart
await db.transaction(() async {
  await db.task.insertOne(
    const TaskInsertOneParams(
      id: 2,
      title: 'Generate Dart',
      priority: 'NORMAL',
      completed: 0,
    ),
  );

  await db.task.completeById(const TaskCompleteByIdParams(id: 1));
});

```

--------------------------------

### Initialize Database with Migrations

Source: https://mobiletoly.github.io/sqlitenow-kmp/documentation/migration

Demonstrates how to pass the generated migration class to the database constructor when initializing the database.

```kotlin
val db = SampleDatabase(
    dbName = "sample.db",
    migration = VersionBasedDatabaseMigrations(),
    // ... other parameters
)

```

--------------------------------

### Directory Structure for Initialization SQL

Source: https://mobiletoly.github.io/sqlitenow-kmp/kmp/sql-reference/initialize-data

Place your initialization SQL files within the `src/commonMain/sql/AppDatabase/init/` directory. Files are executed in deterministic order based on their names.

```plaintext
src/commonMain/sql/AppDatabase/init/
  seed.sql
```

--------------------------------

### Basic Data Initialization

Source: https://mobiletoly.github.io/sqlitenow-kmp/documentation/initialize-data

Use standard SQL INSERT statements to populate tables when the database is first created. Ensure the table and column names match your schema.

```sql
-- Insert Person records
INSERT INTO Person (id, first_name, last_name, email, phone, birth_date) 
VALUES (1, 'John', 'Smith', 'john.smith@example.com', '+1-555-123-4567', '1985-03-15');

INSERT INTO Person (id, first_name, last_name, email, phone, birth_date) 
VALUES (2, 'Emma', 'Johnson', 'emma.johnson@example.com', '+1-555-234-5678', '1990-07-22');

INSERT INTO Person (id, first_name, last_name, email, phone, birth_date) 
VALUES (3, 'Michael', 'Williams', 'michael.williams@example.com', '+1-555-345-6789', '1978-11-30');

```

--------------------------------

### Migration File Naming Convention

Source: https://mobiletoly.github.io/sqlitenow-kmp/flutter/migrations

Specifies the required format for migration file names, starting with a four-digit version number.

```plaintext
lib/db/sql/AppDatabase/migration/
  0002_add_task_due_date.sql
  0003_add_task_archived.sql

```

--------------------------------

### Select All Tasks

Source: https://mobiletoly.github.io/sqlitenow-kmp/flutter/getting-started

Demonstrates how to fetch all tasks from the database using the `selectAll` method and retrieve them as a list.

```dart
final tasks = await db.task.selectAll().asList();
final first = tasks.first;

print('${first.title}: ${first.priority}');

```

--------------------------------

### Executing Basic INSERT

Source: https://mobiletoly.github.io/sqlitenow-kmp/documentation/manage-data

Demonstrates how to execute a basic INSERT operation using the generated query object and its parameters class. No extra execute() step is needed.

```kotlin
// Insert a new person
db.person.add(
    PersonQuery.Add.Params(
        firstName = "John",
        lastName = "Doe",
        email = "john@example.com",
        phone = "+1234567890",
        birthDate = LocalDate(1990, 1, 1),
    )
)
```

--------------------------------

### Execute SELECT ALL Query as List

Source: https://mobiletoly.github.io/sqlitenow-kmp/documentation/query-data

Demonstrates executing a SELECT query using the `asList()` method to retrieve all matching rows as a List. Suitable for queries returning multiple rows.

```kotlin
val persons: List<PersonQuery.SelectAll.Result> = db.person
    .selectAll(PersonQuery.SelectAll.Params(limit = 10, offset = 0))
    .asList()

```

--------------------------------

### Define Enum with Stable Values and Lookup

Source: https://mobiletoly.github.io/sqlitenow-kmp/recipes/serialization

Define an enum with a 'value' property and a companion object implementing `EnumByValueLookup` for easy mapping. This example uses `AddressType`.

```kotlin
enum class AddressType(val value: String) {
    HOME("home"),
    WORK("work");

    companion object : EnumByValueLookup<String, AddressType>(entries.associateBy { it.value })
}

```

--------------------------------

### Define SelectAll Task Query

Source: https://mobiletoly.github.io/sqlitenow-kmp/flutter/getting-started

Create a SQL query file for selecting all tasks. The file path determines the query namespace.

```sql
SELECT id, title, priority, completed
FROM task
ORDER BY id;

```

--------------------------------

### App Entry Points and Database Initialization

Source: https://mobiletoly.github.io/sqlitenow-kmp/tutorials/part-3-reactive-ui

Sets up the main Composable function for the Mood Tracker app. It initializes the database using `rememberDatabase` and displays either a loading state or the main content based on database availability.

```kotlin
package com.example.moodtracker

import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.padding
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Surface
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.MutableState
import androidx.compose.runtime.collectAsState
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.rememberCoroutineScope
import androidx.compose.runtime.setValue
import androidx.compose.ui.Modifier
import androidx.compose.ui.tooling.preview.Preview
import androidx.compose.ui.unit.dp
import com.example.moodtracker.data.MoodDatabaseFactory
import com.example.moodtracker.data.MoodEntryWithTags
import com.example.moodtracker.data.MoodTrackerDatabase
import com.example.moodtracker.ui.theme.MoodTrackerScreen
import com.example.moodtracker.ui.theme.WeeklySummaryCard
import com.example.moodtracker.ui.theme.EntriesList
import com.example.moodtracker.ui.theme.QuickAddBlock
import com.example.moodtracker.ui.theme.MoodPicker
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.text.KeyboardActions
import androidx.compose.foundation.text.KeyboardOptions
import androidx.compose.material3.Button
import androidx.compose.material3.Card
import androidx.compose.material3.OutlinedTextField
import androidx.compose.ui.Alignment
import androidx.compose.ui.text.input.ImeAction

@Composable
@Preview
fun App() {
    MaterialTheme {
        Surface(modifier = Modifier.fillMaxSize()) {
            val databaseState = rememberDatabase()
            val database = databaseState.value
            if (database == null) {
                LoadingState()
            } else {
                MoodTrackerContent(database)
            }
        }
    }
}

@Composable
private fun rememberDatabase(): MutableState<MoodTrackerDatabase?> {
    val state = remember { mutableStateOf<MoodTrackerDatabase?>(null) }
    LaunchedEffect(Unit) {
        if (state.value == null) {
            state.value = MoodDatabaseFactory().create()
        }
    }
    return state
}

@Composable
private fun LoadingState() {
    // Placeholder for loading indicator
    Text("Loading...")
}

@Composable
private fun MoodTrackerContent(database: MoodTrackerDatabase) {
    val scope = rememberCoroutineScope()
    val viewModel = remember(database) {
        MoodTrackerViewModel(
            database = database,
            entryRepository = MoodEntryRepository(database),
            scope = scope,
        )
    }

    val entries by viewModel.entries.collectAsState()
    val summary by viewModel.weeklySummary.collectAsState()
    val isSaving by viewModel.isSaving.collectAsState()

    MoodTrackerScreen(
        entries = entries,
        summary = summary,
        isSaving = isSaving,
        onAdd = { score, note -> viewModel.addEntry(score, note) },
    )
}

```

--------------------------------

### SQL Initialization File Location

Source: https://mobiletoly.github.io/sqlitenow-kmp/flutter/sql-reference/initialize-data

Place your SQL initialization files within the `init/` directory of your database schema. These files are executed in a deterministic order based on their filenames.

```text
lib/db/sql/AppDatabase/init/
  seed.sql
```

--------------------------------

### Providing Custom Type Adapter Implementations

Source: https://mobiletoly.github.io/sqlitenow-kmp/documentation/create-schema

Instantiate the database by providing the concrete implementations for the custom type adapters. Ensure the parsing and formatting logic matches your data types.

```kotlin
val db = SampleDatabase(
    dbName = "sample.db",
    migration = VersionBasedDatabaseMigrations(),
    personAdapters = SampleDatabase.PersonAdapters(
        sqlColumnToBirthDate = { it?.let { LocalDate.parse(it) } },
        birthDateToSqlColumn = { it?.toString() },
        sqlColumnToCreatedAt = { Instant.fromRfc3339String(it) },
        createdAtToSqlColumn = { it.toRfc3339String() },
        phoneToSqlColumn = { it }
    )
)

```

--------------------------------

### Executing Returning Statements

Source: https://mobiletoly.github.io/sqlitenow-kmp/documentation/manage-data

Demonstrates how to use returning statements with INSERT queries, including helpers like `list`, `one`, and `oneOrNull`. These allow retrieving data immediately after modification.

```kotlin
val insertParams = PersonQuery.AddReturning.Params(
    firstName = "Alice",
    lastName = "Smith",
    email = "alice@example.com",
    phone = null,
    birthDate = LocalDate(1992, 5, 15),
)

val inserted = db.person.add.one(insertParams)
val allRows = db.person.add(insertParams)       // operator fun invoke -> List
val maybeRow = db.person.add.oneOrNull(insertParams)
```

--------------------------------

### Define Table Schema for Enum Serialization

Source: https://mobiletoly.github.io/sqlitenow-kmp/recipes/serialization

Use a TEXT column to store the stable string value of an enum. This example shows an 'address_type' field for a 'person_address' table.

```sql
CREATE TABLE person_address
(
    id           INTEGER PRIMARY KEY NOT NULL,

    -- @@{ field=address_type, adapter=custom, propertyType=AddressType }
    address_type TEXT    NOT NULL
)

```

--------------------------------

### Define Table Schema for JSON Collection Serialization

Source: https://mobiletoly.github.io/sqlitenow-kmp/recipes/serialization

Use a TEXT column with a custom adapter to store JSON-serialized collections. This example shows a 'tags' field for a 'comment' table.

```sql
CREATE TABLE comment
(
    id   INTEGER PRIMARY KEY NOT NULL,

    -- @@{ field=tags, adapter=custom, propertyType=List<String> }
    tags TEXT
)

```

--------------------------------

### Define Table Schema for Timestamp Serialization

Source: https://mobiletoly.github.io/sqlitenow-kmp/recipes/serialization

Use a TEXT column with a default value of the current timestamp to store RFC3339 formatted timestamps. This example shows a 'created_at' field for a 'comment' table.

```sql
CREATE TABLE comment
(
    id         INTEGER PRIMARY KEY NOT NULL,

    -- @@{ field=created_at, adapter=custom, propertyType=kotlin.time.Instant }
    created_at TEXT    NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%SZ', 'now'))
)

```

--------------------------------

### Initialize Database with Custom Adapters

Source: https://mobiletoly.github.io/sqlitenow-kmp/flutter/sql-reference/create-schema

Demonstrates initializing the AppDatabase with custom adapters for handling domain-specific types. The adapters define how to convert between the SQLite column value and the Dart type.

```dart
final db = AppDatabase(
  path: path,
  taskAdapters: TaskAdapters(
    sqlColumnToStatus: TaskStatus.parse,
    statusToSqlColumn: (status) => status.name,
  ),
);

```

--------------------------------

### Configure Timestamp Adapters

Source: https://mobiletoly.github.io/sqlitenow-kmp/recipes/serialization

Configure adapters to map between RFC3339 strings and `kotlin.time.Instant` for the 'created_at' column.

```kotlin
val db = SampleDatabase(
    dbName = resolveDatabasePath(dbName = "sample.db", appName = "SampleApp"),
    migration = VersionBasedDatabaseMigrations(),
    commentAdapters = SampleDatabase.CommentAdapters(
        sqlColumnToCreatedAt = { value -> Instant.fromRfc3339String(value) },
        createdAtToSqlColumn = { instant -> instant.toRfc3339String() },
    )
)

```

--------------------------------

### Create Oversqlite Client

Source: https://mobiletoly.github.io/sqlitenow-kmp/sync/getting-started

Instantiate the oversqlite client using the `newOversqliteClient` function, providing the schema name, authenticated HttpClient, and a conflict resolution strategy.

```kotlin
val client = db.newOversqliteClient(
    schema = "myapp",
    httpClient = httpClient,
    resolver = ServerWinsResolver,
)

```

--------------------------------

### Named Parameters with Explicit Casts in CTE

Source: https://mobiletoly.github.io/sqlitenow-kmp/kmp/recipes/named-parameters

When a named parameter is used within a function, CTE, JSON expression, or arithmetic expression, use explicit casts to ensure correct type inference. This example demonstrates casting year and month to INTEGER within a CTE.

```sql
WITH range AS (
  SELECT
    date(printf('%04d-%02d-01', CAST(:year AS INTEGER), CAST(:month AS INTEGER))) AS start_date
)
SELECT *
FROM task
WHERE created_at >= (SELECT start_date FROM range);

```

--------------------------------

### Migration with Data Backfill and Index Creation

Source: https://mobiletoly.github.io/sqlitenow-kmp/flutter/migrations

Applies a schema change, backfills existing data, and creates an index for an existing table.

```sql
ALTER TABLE task ADD COLUMN archived INTEGER NOT NULL DEFAULT 0;

UPDATE task
SET archived = 0
WHERE archived IS NULL;

CREATE INDEX idx_task_archived ON task(archived);

```

--------------------------------

### Configure SQLiteNow Databases

Source: https://mobiletoly.github.io/sqlitenow-kmp/tutorials/part-1-bootstrap

Define your database configuration, including its name, package for generated Kotlin code, and debug logging options. This links your SQL files to the generated database entry point.

```gradle
sqliteNow {
    databases {
        create("MoodTrackerDatabase") {
            packageName.set("dev.goquick.sample.moodtracker.db")
            debug = false // set true when you need verbose logging while debugging SQL
        }
    }
}

```

--------------------------------

### Create Task Table and Index

Source: https://mobiletoly.github.io/sqlitenow-kmp/flutter/sql-reference/create-schema

Defines the 'task' table with columns for id, title, completed, and created_at, and creates an index on the 'completed' column. Ensure schema files are kept up-to-date.

```sql
CREATE TABLE task
(
    id           INTEGER PRIMARY KEY NOT NULL,
    title        TEXT                NOT NULL,
    completed    INTEGER             NOT NULL DEFAULT 0,
    created_at   TEXT                NOT NULL
);

CREATE INDEX idx_task_completed ON task (completed);

```

--------------------------------

### Execute Basic SELECT in Dart

Source: https://mobiletoly.github.io/sqlitenow-kmp/flutter/sql-reference/query-data

Demonstrates how to execute the basic SELECT query and iterate over the results in Dart. Assumes the query is mapped to `db.task.selectAll()`.

```dart
final rows = await db.task.selectAll().asList();

for (final row in rows) {
  print(row.title);
}
```

--------------------------------

### Directory Structure for SQLiteNow Migrations

Source: https://mobiletoly.github.io/sqlitenow-kmp/flutter/migrations

Organizes schema, initialization, and migration files for your SQLite database.

```plaintext
lib/db/sql/AppDatabase/
  schema/
  init/
  migration/
  queries/

```

--------------------------------

### Execute SELECT by ID Query as One

Source: https://mobiletoly.github.io/sqlitenow-kmp/documentation/query-data

Demonstrates executing a SELECT query using the `asOne()` method. This method returns exactly one row and throws an exception if zero or multiple rows are found.

```kotlin
val person: PersonQuery.SelectById.Result = db.person
    .selectById(PersonQuery.SelectById.Params(id = 1))
    .asOne()

```

--------------------------------

### Initialize Multiple Tables

Source: https://mobiletoly.github.io/sqlitenow-kmp/documentation/initialize-data

You can insert data into multiple tables within the same initialization file. Maintain referential integrity by correctly using foreign key relationships.

```sql
-- Insert Person records
INSERT INTO person (id, first_name, last_name, email) 
VALUES (1, 'John', 'Smith', 'john.smith@example.com');

INSERT INTO person (id, first_name, last_name, email) 
VALUES (2, 'Emma', 'Johnson', 'emma.johnson@example.com');

-- Insert person_address records
INSERT INTO person_address (id, person_id, address_type, street, city, state, postal_code, country, is_primary)
VALUES (1, 1, 'HOME', '123 Main St', 'New York', 'NY', '10001', 'USA', 1);

INSERT INTO person_address (id, person_id, address_type, street, city, state, postal_code, country, is_primary)
VALUES (2, 2, 'HOME', '456 Oak Ave', 'Los Angeles', 'CA', '90001', 'USA', 1);

-- Work addresses
INSERT INTO person_address (id, person_id, address_type, street, city, state, postal_code, country, is_primary)
VALUES (3, 1, 'WORK', '100 Business Plaza', 'New York', 'NY', '10002', 'USA', 0);

```

--------------------------------

### Configure Database Adapters for Custom Types

Source: https://mobiletoly.github.io/sqlitenow-kmp/tutorials/part-2-tags-and-filters

Set up lambdas to convert between custom types (Uuid, Instant) and their SQL representations (TEXT) when constructing the database. This ensures platform-agnostic conversion logic.

```kotlin
suspend fun create(): MoodTrackerDatabase {
    val uuidToSql: (Uuid) -> String = { it.toString() }
    val sqlToUuid: (String) -> Uuid = { Uuid.parse(it) }
    val instantToSql: (Instant) -> String = { it.toRfc3339String() }
    val sqlToInstant: (String) -> Instant = { Instant.fromRfc3339String(it) }

    val appName = "MoodTracker"
    val resolvedName = if (dbName.startsWith(":")) dbName else resolveDatabasePath(
        dbName = dbName,
        appName = appName
    )
    val database = MoodTrackerDatabase(
        dbName = resolvedName,
        migration = VersionBasedDatabaseMigrations(),
        debug = debug,
        moodEntryAdapters = MoodTrackerDatabase.MoodEntryAdapters(
            idToSqlValue = uuidToSql,
            entryTimeToSqlValue = instantToSql,
            sqlValueToId = sqlToUuid,
            sqlValueToEntryTime = sqlToInstant,
        ),
        moodEntryTagAdapters = MoodTrackerDatabase.MoodEntryTagAdapters(
            entryIdToSqlValue = uuidToSql,
            tagIdToSqlValue = uuidToSql,
        ),
    )
    database.open()
    return database
}

```

--------------------------------

### Define InsertOne Task Query

Source: https://mobiletoly.github.io/sqlitenow-kmp/flutter/getting-started

Create a SQL query file for inserting a new task. Named parameters like ':id' become generated fields.

```sql
INSERT INTO task (id, title, priority, completed)
VALUES (:id, :title, :priority, :completed);

```

--------------------------------

### KMP Project Migration Directory Structure

Source: https://mobiletoly.github.io/sqlitenow-kmp/kmp/migrations

Defines the standard directory structure for SQL schema and migration files within a Kotlin Multiplatform project.

```plaintext
src/commonMain/sql/AppDatabase/
  schema/
  init/
  migration/
  queries/

```

--------------------------------

### Add SQLiteNow Runtime and Dependencies

Source: https://mobiletoly.github.io/sqlitenow-kmp/tutorials/part-1-bootstrap

Include the SQLiteNow core runtime in `commonMain` and the bundled SQLite driver in platform-specific source sets like `androidMain`. Also, add the `kotlinx-datetime` library for date-time functionalities.

```kotlin
kotlin {
    // …
    sourceSets {
        commonMain.dependencies {
            implementation("dev.goquick.sqlitenow:core:<latest-version>")
            implementation("org.jetbrains.kotlinx:kotlinx-datetime:0.6.1")
        }
        androidMain.dependencies {
            implementation("androidx.sqlite:sqlite-bundled:2.6.1")
        }
    }
}

```

--------------------------------

### Configure SQLiteNow Databases

Source: https://mobiletoly.github.io/sqlitenow-kmp/getting-started

Configure the SQLiteNow plugin by defining your database name, package name, and debug mode in the build script.

```kotlin
sqliteNow {
    databases {
        create("SampleDatabase") {
            packageName.set("com.example.app.db")
            debug = false
        }
    }
}


```

--------------------------------

### Initialize Database with Custom Adapters

Source: https://mobiletoly.github.io/sqlitenow-kmp/flutter/recipes/serialization

Initialize the AppDatabase with custom adapters for the 'tags' field, providing functions to convert between the SQLite TEXT representation and the Dart List<String> domain type.

```dart
final db = AppDatabase(
  path: path,
  taskAdapters: TaskAdapters(
    sqlColumnToTags: (value) => List<String>.from(jsonDecode(value)),
    tagsToSqlColumn: (tags) => jsonEncode(tags),
  ),
);

```

--------------------------------

### Quick Add Form Composable

Source: https://mobiletoly.github.io/sqlitenow-kmp/tutorials/part-3-reactive-ui

Implements the UI for adding a new mood entry. Includes a text field for notes, a mood picker, and an add button. The input fields and button are enabled based on the `isSaving` state.

```kotlin
@Composable
private fun QuickAddBlock(
    note: String,
    onNoteChange: (String) -> Unit,
    selectedMood: Int,
    onMoodChange: (Int) -> Unit,
    onAdd: () -> Unit,
    enabled: Boolean,
) {
    Card {
        Column(
            modifier = Modifier.padding(16.dp),
            verticalArrangement = Arrangement.spacedBy(12.dp),
        ) {
            Text(
                text = "Add how you feel right now",
                style = MaterialTheme.typography.titleMedium,
            )

            OutlinedTextField(
                value = note,
                onValueChange = onNoteChange,
                modifier = Modifier.fillMaxWidth(),
                placeholder = { Text("Optional note") },
                maxLines = 3,
                keyboardOptions = KeyboardOptions.Default.copy(imeAction = ImeAction.Done),
                keyboardActions = KeyboardActions(onDone = { onAdd() }),
            )

            MoodPicker(
                selectedMood = selectedMood,
                onMoodChange = onMoodChange,
            )

            Button(
                onClick = onAdd,
                enabled = enabled,
                modifier = Modifier.align(Alignment.End),
            ) {
                Text("Add entry")
            }
        }
    }
}

```

--------------------------------

### Add SQLiteNow Version to libs.version.toml

Source: https://mobiletoly.github.io/sqlitenow-kmp/getting-started

Define versions for SQLiteNow, bundled SQLite, and kotlinx-datetime in your version catalog.

```toml
[version]
sqlite = "2.6.2"
sqlitenow = "0.9.1"
kotlinx-datetime = "0.7.1"

[libraries]
sqlitenow-kmp = { module = "dev.goquick.sqlitenow:core", version.ref = "sqlitenow" }
sqlite-bundled = { module = "androidx.sqlite:sqlite-bundled", version.ref = "sqlite" }
kotlinx-datetime = { module = "org.jetbrains.kotlinx:kotlinx-datetime", version.ref = "kotlinx-datetime" }

[plugins]
sqlitenow = { id = "dev.goquick.sqlitenow", version.ref = "sqlitenow" }


```

--------------------------------

### Add Core and Oversqlite Runtime Dependencies

Source: https://mobiletoly.github.io/sqlitenow-kmp/sync/getting-started

Include the necessary SQLiteNow runtime artifacts in your common main dependencies to enable sync functionality.

```kotlin
commonMain.dependencies {
    implementation("dev.goquick.sqlitenow:core:<latest-version>")
    implementation("dev.goquick.sqlitenow:oversqlite:<latest-version>")
}

```

--------------------------------

### Enable SQLiteNow Gradle Plugin

Source: https://mobiletoly.github.io/sqlitenow-kmp/tutorials/part-1-bootstrap

Add the SQLiteNow Gradle plugin ID to your `build.gradle.kts` file. This enables the code generation process for your database.

```gradle
plugins {
    // … existing plugin declarations …
    id("dev.goquick.sqlitenow") version "<latest-version>"
}

```

--------------------------------

### Basic Named Parameter Usage

Source: https://mobiletoly.github.io/sqlitenow-kmp/flutter/recipes/named-parameters

Demonstrates a basic SQL query using a named parameter ':id'. SQLiteNow infers the parameter type from its usage.

```sql
SELECT id, title
FROM task
WHERE id = :id;
```

--------------------------------

### Configure build.gradle.kts for SQLiteNow

Source: https://mobiletoly.github.io/sqlitenow-kmp/getting-started

Apply the SQLiteNow plugin and add runtime dependencies to your composeApp's build.gradle.kts. Ensure sqlite-bundled is added only to platform-specific source sets, not commonMain, especially if targeting Wasm.

```kotlin
plugins {
    // ...
    alias(libs.plugins.sqlitenow)
}

kotlin {
    sourceSets {
        commonMain.dependencies {
            // ...
            implementation(libs.sqlitenow.kmp)
            implementation(libs.kotlinx.datetime)
        }

        // Add sqlite-bundled only to targets that publish this dependency.
        // Do not place it in commonMain if your project has wasmJs target.
        androidMain.dependencies {
            implementation(libs.sqlite.bundled)
        }

        iosMain.dependencies {
            implementation(libs.sqlite.bundled)
        }
    }
}


```

--------------------------------

### Adding a Column to an Existing Table

Source: https://mobiletoly.github.io/sqlitenow-kmp/flutter/migrations

Demonstrates how to add a new column to a table for version 2, updating both the schema and creating a migration file.

```sql
CREATE TABLE task (
  id INTEGER PRIMARY KEY NOT NULL,
  title TEXT NOT NULL,
  completed INTEGER NOT NULL,
  due_at TEXT
);

```

```sql
ALTER TABLE task ADD COLUMN due_at TEXT;

```

--------------------------------

### Define Database Schema

Source: https://mobiletoly.github.io/sqlitenow-kmp/tutorials/part-1-bootstrap

Create the table structure for your database. This SQL defines the columns and constraints for the 'mood_entry' table.

```sql
CREATE TABLE mood_entry (
    id TEXT PRIMARY KEY NOT NULL,
    entry_time TEXT NOT NULL,
    mood_score INTEGER NOT NULL,
    note TEXT
);

CREATE INDEX idx_mood_entry_entry_time ON mood_entry(entry_time);

```

--------------------------------

### Apply SQLiteNow Plugin in Root build.gradle.kts

Source: https://mobiletoly.github.io/sqlitenow-kmp/getting-started

Apply the SQLiteNow plugin in your project's root-level build.gradle.kts file.

```kotlin
plugins {
    // ...
    alias(libs.plugins.sqlitenow) apply false
}


```

--------------------------------

### Create Authenticated HttpClient

Source: https://mobiletoly.github.io/sqlitenow-kmp/sync/getting-started

Construct a Ktor HttpClient with authentication support, including token loading and refreshing mechanisms, for secure communication with the oversqlite server.

```kotlin
fun createSyncHttpClient(
    baseUrl: String,
    getToken: suspend () -> String?,
    refreshToken: suspend () -> String?
): HttpClient {
    return HttpClient {
        install(ContentNegotiation) {
            json(Json {
                ignoreUnknownKeys = true
            })
        }
        install(Auth) {
            bearer {
                loadTokens {
                    getToken()?.let { BearerTokens(it, "") }
                }
                refreshTokens {
                    refreshToken()?.let { BearerTokens(it, "") }
                }
            }
        }
        defaultRequest {
            url(baseUrl)
        }
    }
}

```

--------------------------------

### Basic Reactive Query with Kotlin Flows

Source: https://mobiletoly.github.io/sqlitenow-kmp/recipes/reactive-flows

Fetch data from the database and collect it as a flow to update UI state. Use LaunchedEffect to manage the flow collection lifecycle within Compose.

```kotlin
import androidx.compose.runtime.* 
import androidx.compose.foundation.lazy.LazyColumn
import androidx.compose.foundation.lazy.items

@Composable
fun PersonList() {
    var persons by remember { mutableStateOf<List<PersonEntity>>(emptyList()) } 
    var isLoading by remember { mutableStateOf(true) } 

    LaunchedEffect(Unit) {
        database.person
            .selectAll(PersonQuery.SelectAll.Params(limit = -1, offset = 0))
            .asFlow()               // Reactive flow
            .collect { personList ->
                persons = personList
                isLoading = false
            }
    }

    LazyColumn {
        items(persons) {
            PersonCard(person = person)
        }
    }
}
```

--------------------------------

### Reactive Data Watching in Dart

Source: https://mobiletoly.github.io/sqlitenow-kmp/flutter/sql-reference/query-data

Demonstrates how to use the `watch()` method for reactive data retrieval in Dart. This allows for real-time updates when the data changes.

```dart
final subscription = db.task.selectAll().watch().listen((rows) {
  setState(() => tasks = rows);
});
```

--------------------------------

### Configure JSON Collection Adapters

Source: https://mobiletoly.github.io/sqlitenow-kmp/recipes/serialization

Configure adapters using `jsonDecodeFromSqlite` and `jsonEncodeToSqlite` to handle List<String> serialization for the 'tags' column.

```kotlin
val db = SampleDatabase(
    dbName = resolveDatabasePath(dbName = "sample.db", appName = "SampleApp"),
    migration = VersionBasedDatabaseMigrations(),
    commentAdapters = SampleDatabase.CommentAdapters(
        sqlColumnToTags = { value -> value?.jsonDecodeFromSqlite() ?: emptyList() },
        tagsToSqlColumn = { tags -> tags?.jsonEncodeToSqlite() }
    )
)

```

--------------------------------

### Generate SQLiteNow Code

Source: https://mobiletoly.github.io/sqlitenow-kmp/flutter/example

Run these commands in the `dart/examples/flutter_todo` directory to generate Dart database code from your SQL schema and configuration.

```bash
flutter pub get
flutter pub run sqlitenow_cli generate

```

--------------------------------

### Generate Database Code with Gradle

Source: https://mobiletoly.github.io/sqlitenow-kmp/getting-started

Run the Gradle plugin to generate Kotlin code from your SQL queries. The generated code is placed in the build directory.

```bash
./gradlew :composeApp:generateSampleDatabase

```

--------------------------------

### Explicitly Rebuild Sqlitenow Client

Source: https://mobiletoly.github.io/sqlitenow-kmp/sync/getting-started

Call `client.rebuild()` as the explicit recovery entry point. Oversqlite determines internally whether to keep the current source or perform a rebuild-plus-rotate recovery.

```kotlin
client.rebuild().getOrThrow()
```

--------------------------------

### Inspect Sqlitenow Client Source Diagnostics

Source: https://mobiletoly.github.io/sqlitenow-kmp/sync/getting-started

Retrieve `SourceInfo` using `client.sourceInfo()` for diagnostics. `currentSourceId` is opaque and should not be used for app control.

```kotlin
val info = client.sourceInfo().getOrThrow()
println(info.currentSourceId)
println(info.rebuildRequired)
println(info.sourceRecoveryRequired)
```

--------------------------------

### Configure Schema Database Persistence

Source: https://mobiletoly.github.io/sqlitenow-kmp/kmp/recipes/inspection

Configure the Gradle plugin to create and persist the schema database file. This file can be opened with a SQLite client to inspect tables, indexes, views, and inferred schema state.

```kotlin
sqliteNow {
    databases {
        create("AppDatabase") {
            packageName.set("com.example.app.db")
            schemaDatabaseFile.set(layout.projectDirectory.file("tmp/schema.db"))
        }
    }
}

```

--------------------------------

### Implement Mood Entry Repository

Source: https://mobiletoly.github.io/sqlitenow-kmp/tutorials/part-2-tags-and-filters

Provides methods for adding new mood entries and retrieving recent entries with their associated tags, including both suspend functions and reactive flows.

```kotlin
class MoodEntryRepository(private val database: MoodTrackerDatabase) {

    data class NewMoodEntry(
        val entryTime: Instant,
        val moodScore: Int,
        val note: String?,
        val id: Uuid = Uuid.random(),
    )

    suspend fun add(entry: NewMoodEntry): MoodEntryRow {
        return database.moodEntry.add.one(
            MoodEntryQuery.Add.Params(
                id = entry.id,
                entryTime = entry.entryTime,
                moodScore = entry.moodScore,
                note = entry.note,
            )
        )
    }

    suspend fun recentWithTags(limit: Int): List<MoodEntryWithTags> {
        return database.moodEntry.selectRecentWithTags(
            MoodEntryQuery.SelectRecentWithTags.Params(limit = limit.toLong())
        ).asList()
    }

    fun recentWithTagsFlow(limit: Int): Flow<List<MoodEntryWithTags>> {
        return database.moodEntry.selectRecentWithTags(
            MoodEntryQuery.SelectRecentWithTags.Params(limit = limit.toLong())
        ).asFlow()
    }
}

```

--------------------------------

### Executing UPDATE Email

Source: https://mobiletoly.github.io/sqlitenow-kmp/documentation/manage-data

Shows how to execute an UPDATE operation to change an email address using the generated query object and parameters. Modifications run immediately.

```kotlin
// Update an email address
db.person.updateEmail(
    PersonQuery.UpdateEmail.Params(
        id = 1,
        email = "newemail@example.com",
    )
)
```

--------------------------------

### Execute Basic SELECT Query in KMP

Source: https://mobiletoly.github.io/sqlitenow-kmp/kmp/sql-reference/query-data

Call the generated KMP method to fetch all rows from a table. The result is a list of objects, each representing a row.

```kotlin
val rows = db.task.selectAll().asList()

rows.forEach { row ->
    println(row.title)
}
```

--------------------------------

### Resolve Database Path in Factory

Source: https://mobiletoly.github.io/sqlitenow-kmp/tutorials/part-3-reactive-ui

Uses the shared SQLiteNow helper to determine the correct database file location across platforms. Handles special names like ":memory:" directly.

```kotlin
val appName = "MoodTracker"
val resolvedName = if (dbName.startsWith(":")) dbName else resolveDatabasePath(
    dbName = dbName,
    appName = appName
)
val database = MoodTrackerDatabase(
    dbName = resolvedName,
    migration = VersionBasedDatabaseMigrations(),
    debug = debug,
    // ... adapters ...
)
```

--------------------------------

### Run Gradle Task for Code Generation

Source: https://mobiletoly.github.io/sqlitenow-kmp/tutorials/part-1-bootstrap

Execute the Gradle task to generate Kotlin sources from your SQL definitions. This task validates SQL statements and creates database-related Kotlin files.

```bash
./gradlew :composeApp:generateMoodTrackerDatabase

```

--------------------------------

### SQL Query Structure

Source: https://mobiletoly.github.io/sqlitenow-kmp/documentation/query-data

SQL SELECT queries are organized in the `queries/` directory using namespaces. Each namespace typically corresponds to a table.

```directory
src/commonMain/sql/SampleDatabase/queries/
├── person/
│   ├── selectAll.sql
│   ├── selectById.sql

```

--------------------------------

### Query All Persons

Source: https://mobiletoly.github.io/sqlitenow-kmp/getting-started

Open the database and execute a query to retrieve all persons, specifying parameters for limit and offset. The result is converted to a list.

```kotlin
LaunchedEffect(Unit) {
    // Open the database (you need to find a better place for this code, but for the sake of example it's here)
    db.open()
    
    // Query all persons
    val personList: List<PersonQuery.SelectAll.Result> = db.person
        .selectAll(
            PersonQuery.SelectAll.Params(
                limit = -1,
                offset = 0
            )
        )
        .asList()
}


```

--------------------------------

### Basic SELECT Query

Source: https://mobiletoly.github.io/sqlitenow-kmp/flutter/sql-reference/query-data

This SQL query retrieves all tasks ordered by creation date. It generates a Dart method for fetching all rows.

```sql
SELECT id, title, completed, created_at
FROM task
ORDER BY created_at DESC;
```

--------------------------------

### Implement Mood Tag Repository

Source: https://mobiletoly.github.io/sqlitenow-kmp/tutorials/part-2-tags-and-filters

Manages mood tags, including adding new tags, retrieving all tags, assigning tags to entries, and fetching entries associated with a specific tag.

```kotlin
class MoodTagRepository(private val database: MoodTrackerDatabase) {

    suspend fun addTag(name: String): MoodTagRow {
        val params = MoodTagQuery.Add.Params(
            id = Uuid.random(),
            name = name,
        )
        return database.moodTag.add.one(params)
    }

    suspend fun allTags(): List<MoodTagRow> = database.moodTag.selectAll.asList()

    suspend fun assignTag(entryId: Uuid, tagId: Uuid) {
        database.moodEntryTag.add(
            MoodEntryTagQuery.Add.Params(entryId = entryId, tagId = tagId)
        )
    }

    suspend fun entriesForTag(tagId: Uuid): List<MoodEntryRow> {
        return database.moodEntry.selectByTag(
            MoodEntryQuery.SelectByTag.Params(tagId = tagId.toString())
        ).asList()
    }
}

```

--------------------------------

### Add Ktor Client Dependencies

Source: https://mobiletoly.github.io/sqlitenow-kmp/sync/getting-started

Add Ktor client dependencies for network communication, content negotiation, authentication, and JSON serialization. Platform-specific clients (OkHttp for Android, Darwin for iOS) are also required.

```kotlin
commonMain.dependencies {
    implementation("io.ktor:ktor-client-core:3.4.1")
    implementation("io.ktor:ktor-client-content-negotiation:3.4.1")
    implementation("io.ktor:ktor-client-auth:3.4.1")
    implementation("io.ktor:ktor-serialization-kotlinx-json:3.4.1")
}

androidMain.dependencies {
    implementation("io.ktor:ktor-client-okhttp:3.4.1")
}

iosMain.dependencies {
    implementation("io.ktor:ktor-client-darwin:3.4.1")
}

```

--------------------------------

### Define Basic Table Schema

Source: https://mobiletoly.github.io/sqlitenow-kmp/documentation/create-schema

Define your table structure in the `schema/` directory. SQLiteNow converts column names to camelCase properties by default. Use annotations to customize property names.

```SQL
CREATE TABLE person
(
    id         INTEGER PRIMARY KEY NOT NULL,
    first_name TEXT                NOT NULL,
    last_name  TEXT                NOT NULL,
    email      TEXT                NOT NULL UNIQUE,

    -- @@{ field=phone, propertyName=userPhone }
    phone      TEXT,

    created_at TEXT                NOT NULL DEFAULT current_timestamp
);

CREATE INDEX idx_person_email ON Person (email);

```

--------------------------------

### Execute SELECT by ID Query as One Or Null

Source: https://mobiletoly.github.io/sqlitenow-kmp/documentation/query-data

Demonstrates executing a SELECT query using the `asOneOrNull()` method. This method returns one row or null if no rows are found, and throws an exception if multiple rows are found.

```kotlin
val person: PersonQuery.SelectById.Result? = db.person
    .selectById(PersonQuery.SelectById.Params(id = 1))
    .asOneOrNull()

```

--------------------------------

### Generate Schema and Analyze Code

Source: https://mobiletoly.github.io/sqlitenow-kmp/flutter/recipes/inspection

Run these commands to generate schema, analyze your Dart code, and run tests. Ensure generated output is in a stable folder like `lib/db/generated` for IDE inspection.

```bash
flutter pub run sqlitenow_cli generate
dart analyze
flutter test

```

--------------------------------

### Executing DELETE By IDs

Source: https://mobiletoly.github.io/sqlitenow-kmp/documentation/manage-data

Illustrates how to execute a DELETE operation for multiple records by their IDs using the generated query and parameters. The operation is executed immediately.

```kotlin
// Delete multiple people by ID
db.person.deleteByIds(
    PersonQuery.DeleteByIds.Params(
        ids = listOf(1L, 2L, 3L),
    )
)
```

--------------------------------

### Configure Webpack 5 Fallbacks for sql.js

Source: https://mobiletoly.github.io/sqlitenow-kmp/documentation/kotlin-wasm

Set up Webpack 5 fallbacks for Node core modules like 'fs', 'path', and 'crypto' when they are referenced by sql.js. This configuration ensures the Wasm runtime can load correctly in a browser environment.

```javascript
config.resolve = config.resolve || {};
config.resolve.fallback = Object.assign({}, config.resolve.fallback, {
  fs: false,
  path: false,
  crypto: false,
  // Some setups also require these (depends on transitive deps / toolchain):
  wasi_snapshot_preview1: false,
  env: false,
});

config.module = config.module || {};
config.module.rules = Array.isArray(config.module.rules) ? config.module.rules : [];
config.module.rules.push({
  test: /sql\.js\/dist\/sql-wasm\.wasm$/,
  type: "asset/resource",
});

config.experiments = Object.assign({}, config.experiments, { asyncWebAssembly: true });
config.target = "web";

```

--------------------------------

### Simple SELECT ALL SQL Query

Source: https://mobiletoly.github.io/sqlitenow-kmp/documentation/query-data

Defines a basic SELECT ALL query with LIMIT and OFFSET parameters. This SQL query generates corresponding Params and Result data classes.

```sql
SELECT * FROM Person
LIMIT :limit OFFSET :offset;

```

--------------------------------

### Configure SQLiteNow Generator

Source: https://mobiletoly.github.io/sqlitenow-kmp/flutter/getting-started

Configure the SQLiteNow generator in `sqlitenow.yaml`. Specify input SQL directory, output Dart directory, package name, and runtime.

```yaml
databases:
  AppDatabase:
    input: lib/db/sql/AppDatabase
    output: lib/db/generated
    package: app.db
    runtime: dart
    oversqlite: false

```

--------------------------------

### Perform Sync Operations

Source: https://mobiletoly.github.io/sqlitenow-kmp/sync/getting-started

Execute various sync operations: `sync()` for normal interactive sync, `pushPending()` for upload-only, and `pullToStable()` for download-only.

```kotlin
client.sync().getOrThrow()

```

```kotlin
client.pushPending().getOrThrow()

```

```kotlin
client.pullToStable().getOrThrow()

```
Tokens:
Raw