foxhound 2.0.13 → 2.0.15

package/README.md

@@ -1,65 +1,143 @@
 # FoxHound
 
-The FoxHound javascript query generator, for node.js and the browser.
-
-
-### Getting Started
-
-    $ npm install foxhound --save
-
-Then...
-
-    var foxhound = require('foxhound');
-    var my_awesome_query = foxhound.scope('Users').cap(20).generate().query.body;
-    console.log(my_awesome_query);
-
-The default query dialect is english, so, node should output:
-
-    Please give me 20 of your Users.  Thank you!
-
-This is not very useful for anything other than testing, so, we might want to change the dialect and try again:
-
-    var foxhound = require('foxhound');
-    var my_awesome_query = foxhound.scope('Users').cap(20).setDialect('MySQL').generate().query.body;
-    console.log(my_awesome_query);
-
-Which now will output:
-
-    SELECT * FROM Users LIMIT 20;
+> A fluent query generation DSL for Node.js and the browser
+
+FoxHound is a database query builder that generates dialect-specific SQL from a single chainable API.  It keeps your application code database-agnostic while producing safe, parameterized queries for MySQL, Microsoft SQL Server, SQLite, and ALASQL.
+
+## Features
+
+- **Chainable API** — every configuration method returns the query object for fluent composition
+- **Multiple Dialects** — generate SQL for MySQL, MSSQL, SQLite, ALASQL, or plain English from the same code
+- **Parameterized Queries** — user-supplied values are always bound as named parameters, preventing SQL injection
+- **Schema-Aware** — automatic management of identity columns, timestamps, user stamps, and soft-delete tracking
+- **Full CRUD + Count** — build CREATE, READ, UPDATE, DELETE, UNDELETE, and COUNT queries
+- **Query Overrides** — underscore-style templates for custom SQL while retaining automatic parameter binding
+- **Filtering & Sorting** — rich filter expressions with multiple operators, logical grouping, and multi-column sorting
+- **Joins & Pagination** — INNER, LEFT, and custom joins plus dialect-aware LIMIT/OFFSET pagination
+- **Fable Integration** — operates as a Fable service, inheriting configuration, logging, and UUID generation
+
+## Quick Start
+
+```javascript
+const libFable = require('fable');
+const libFoxHound = require('foxhound');
+
+const _Fable = new libFable({});
+const tmpQuery = libFoxHound.new(_Fable);
+
+tmpQuery
+    .setScope('Books')
+    .setDataElements(['Title', 'Author', 'PublishedYear'])
+    .addFilter('Genre', 'Science Fiction')
+    .addSort({Column: 'PublishedYear', Direction: 'Descending'})
+    .setCap(25)
+    .setDialect('MySQL')
+    .buildReadQuery();
+
+console.log(tmpQuery.query.body);
+// => SELECT `Title`, `Author`, `PublishedYear` FROM `Books`
+//    WHERE `Books`.`Genre` = :Genre_w0 ORDER BY PublishedYear DESC LIMIT 25;
+
+console.log(tmpQuery.query.parameters);
+// => { Genre_w0: 'Science Fiction' }
+```
 
-### Testing
+## Installation
 
-    $ npm test
-    $ npm run coverage
+```bash
+npm install foxhound
+```
 
-### Docker Development Environment
+## How It Works
 
+FoxHound follows a configure-then-build pattern.  You create a query instance, chain configuration methods to set the table, columns, filters, sorts, and dialect, then call a build method to generate the SQL.
 
-1. Run this command to build this image:
 ```
-docker build ./ -t retold/foxhound:local
+Application Code
+  └── FoxHound Query
+        ├── setScope('Books')         → target table
+        ├── addFilter('Genre', '...')  → WHERE clause
+        ├── addSort('Title')          → ORDER BY clause
+        ├── setCap(25)                → LIMIT clause
+        ├── setDialect('MySQL')       → output format
+        └── buildReadQuery()          → SQL generation
+              ├── query.body          → SQL string
+              └── query.parameters    → bound values
 ```
 
-alternatively you can use npm to run this
+## Dialects
+
+| Dialect | Target | Identifier Quoting | Parameter Prefix | Pagination |
+|---------|--------|-------------------|-----------------|------------|
+| `MySQL` | MySQL / MariaDB | `` `backticks` `` | `:name` | `LIMIT offset, count` |
+| `MSSQL` | Microsoft SQL Server | `[brackets]` | `@name` | `OFFSET/FETCH` |
+| `SQLite` | SQLite 3 | `` `backticks` `` | `:name` | `LIMIT count OFFSET offset` |
+| `ALASQL` | ALASQL (in-memory) | `` `backticks` `` | `:name` | `LIMIT count FETCH offset` |
+| `English` | Human-readable | none | none | prose |
+| `MeadowEndpoints` | REST URLs | none | none | query string |
+
+## Schema Types
+
+When a schema is attached, FoxHound automatically manages special columns:
+
+| Type | Description |
+|------|-------------|
+| `AutoIdentity` | Auto-increment primary key — `NULL` on insert, skipped on update |
+| `AutoGUID` | Automatically generated UUID on insert |
+| `CreateDate` / `CreateIDUser` | Auto-populated on insert only |
+| `UpdateDate` / `UpdateIDUser` | Auto-populated on insert and update |
+| `DeleteDate` / `DeleteIDUser` | Auto-populated on soft delete |
+| `Deleted` | Soft-delete flag — auto-filtered in reads |
+
+## Filter Operators
+
+| Operator | SQL | Description |
+|----------|-----|-------------|
+| `=` | `=` | Equals (default) |
+| `!=` | `!=` | Not equals |
+| `>`, `>=`, `<`, `<=` | `>`, `>=`, `<`, `<=` | Comparison |
+| `LIKE` | `LIKE` | Pattern match |
+| `IN`, `NOT IN` | `IN (...)`, `NOT IN (...)` | Set membership |
+| `IS NULL`, `IS NOT NULL` | `IS NULL`, `IS NOT NULL` | Null checks |
+| `(`, `)` | `(`, `)` | Logical grouping |
+
+## Testing
+
+```bash
+npm test
+npm run coverage
+```
 
+## Docker Development Environment
 
-```
-npm run docker-dev-build-image
-```
+1. Build the image:
 
-2. Run this command to build the local container:
-```
-docker run -it --name foxhound-dev -p 127.0.0.1:12346:8080 -v "$PWD/.config:/home/coder/.config"  -v "$PWD:/home/coder/foxhound" -u "$(id -u):$(id -g)" -e "DOCKER_USER=$USER" retold/foxhound:local
+```bash
+npm run docker-dev-build
 ```
 
-alternatively you can use npm to run this
+2. Run the container:
 
-```
+```bash
 npm run docker-dev-run
 ```
 
-3. Go to http://localhost:12346/ in a web browser
+3. Open http://localhost:24238/ — the password is "retold"
+
+## Documentation
+
+Detailed documentation is available in the `docs/` folder and can be served locally:
+
+```bash
+npx docsify-cli serve docs
+```
 
-4. The password is "retold"
+## Related Packages
 
-5. Right now you (may) need to delete the `node_modules` folders and regenerate it for Linux.
+- [fable](https://github.com/stevenvelozo/fable) — Core service framework (required dependency)
+- [meadow](https://github.com/stevenvelozo/meadow) — Data access layer that uses FoxHound for query generation
+- [stricture](https://github.com/stevenvelozo/stricture) — Schema definition tool that produces FoxHound-compatible schema arrays
+- [meadow-endpoints](https://github.com/stevenvelozo/meadow-endpoints) — REST endpoint generator built on Meadow + FoxHound
+- [meadow-connection-mysql](https://github.com/stevenvelozo/meadow-connection-mysql) — MySQL connection provider
+- [meadow-connection-mssql](https://github.com/stevenvelozo/meadow-connection-mssql) — MSSQL connection provider
+- [meadow-connection-sqlite](https://github.com/stevenvelozo/meadow-connection-sqlite) — SQLite connection provider

package/docs/.nojekyll

@@ -0,0 +1 @@
+

package/docs/README.md

@@ -0,0 +1,63 @@
+# FoxHound
+
+FoxHound is a fluent query generation DSL for Node.js and the browser.  It produces dialect-specific SQL (or other query formats) from a single chainable API, keeping your application code database-agnostic while generating safe, parameterized queries.
+
+## Features
+
+- **Chainable API** — every configuration method returns the query object, so you can compose queries in a single expression
+- **Multiple Dialects** — generate SQL for MySQL, Microsoft SQL Server, SQLite, ALASQL, or plain English, all from the same code
+- **Parameterized Queries** — user-supplied values are always bound as named parameters, preventing SQL injection
+- **Schema-Aware** — when a schema is provided, FoxHound automatically manages identity columns, timestamps, user stamps, and soft-delete tracking
+- **Full CRUD + Count** — build CREATE, READ, UPDATE, DELETE, UNDELETE, and COUNT queries
+- **Query Overrides** — supply an underscore-style template to customize query generation while still benefiting from automatic parameter binding
+- **Filtering & Sorting** — rich filter expressions with multiple operators, logical grouping, and multi-column sorting
+- **Joins & Pagination** — INNER, LEFT, and custom joins plus dialect-aware LIMIT/OFFSET pagination
+- **Fable Integration** — operates as a Fable service, inheriting configuration, logging, and UUID generation
+
+## Quick Start
+
+```
+$ npm install foxhound
+```
+
+```javascript
+var libFable = require('fable');
+var _Fable = new libFable({});
+
+var tmpQuery = _Fable.Utility.waterfall.FoxHound;
+// Or create a new query directly:
+var libFoxHound = require('foxhound');
+var tmpQuery = libFoxHound.new(_Fable);
+
+tmpQuery.setScope('Users')
+    .setCap(20)
+    .setDialect('MySQL')
+    .buildReadQuery();
+
+console.log(tmpQuery.query.body);
+// => SELECT `Users`.* FROM `Users` LIMIT 20;
+```
+
+## How It Works
+
+1. **Create a Query** — instantiate via `foxhound.new(fable)` or through a Fable service
+2. **Configure** — chain methods to set scope (table), fields, filters, sorts, joins, and pagination
+3. **Set a Dialect** — call `.setDialect('MySQL')` (or MSSQL, SQLite, ALASQL, English)
+4. **Build** — call a build method such as `.buildReadQuery()` to generate the SQL
+5. **Execute** — read the generated SQL from `.query.body` and bound parameters from `.query.parameters`
+
+## Related Packages
+
+| Package | Purpose |
+|---------|---------|
+| [fable](https://github.com/stevenvelozo/fable) | Core service framework (required dependency) |
+| [meadow](https://github.com/stevenvelozo/meadow) | Data access layer that uses FoxHound for query generation |
+| [stricture](https://github.com/stevenvelozo/stricture) | Schema definition tool that produces FoxHound-compatible schema arrays |
+| [meadow-endpoints](https://github.com/stevenvelozo/meadow-endpoints) | REST endpoint generator built on Meadow + FoxHound |
+
+## Testing
+
+```
+$ npm test
+$ npm run coverage
+```

package/docs/_sidebar.md

@@ -0,0 +1,34 @@
+- Getting Started
+
+  - [Introduction](/)
+  - [Architecture](architecture.md)
+
+- Query Building
+
+  - [Query Overview](query/README.md)
+  - [Create](query/create.md)
+  - [Read](query/read.md)
+  - [Update](query/update.md)
+  - [Delete](query/delete.md)
+  - [Count](query/count.md)
+
+- Filtering & Sorting
+
+  - [Filters](filters.md)
+  - [Sorting](sorting.md)
+  - [Joins](joins.md)
+  - [Pagination](pagination.md)
+
+- Dialects
+
+  - [Dialects Overview](dialects/README.md)
+  - [MySQL](dialects/mysql.md)
+  - [MSSQL](dialects/mssql.md)
+  - [SQLite](dialects/sqlite.md)
+  - [ALASQL](dialects/alasql.md)
+
+- Advanced
+
+  - [Schema Integration](schema.md)
+  - [Query Overrides](query-overrides.md)
+  - [Configuration Reference](configuration.md)

package/docs/architecture.md

@@ -0,0 +1,104 @@
+# Architecture
+
+FoxHound follows a clean separation between query configuration, dialect-specific generation, and result handling.
+
+## Overview
+
+```
+┌─────────────────────────────────────┐
+│          Application Code           │
+│   query.setScope('Books')           │
+│        .addFilter('Genre','Sci-Fi') │
+│        .setDialect('MySQL')         │
+│        .buildReadQuery()            │
+└──────────────┬──────────────────────┘
+               │
+┌──────────────▼──────────────────────┐
+│         FoxHound Core               │
+│  - Parameters object (state)        │
+│  - Chainable configuration API      │
+│  - Dialect selection & delegation   │
+└──────────────┬──────────────────────┘
+               │
+┌──────────────▼──────────────────────┐
+│         Dialect Engine              │
+│  MySQL │ MSSQL │ SQLite │ ALASQL   │
+│  - Generates SQL string            │
+│  - Populates named parameters      │
+│  - Applies schema-aware logic      │
+└──────────────┬──────────────────────┘
+               │
+┌──────────────▼──────────────────────┐
+│         Query Output                │
+│  query.body       → SQL string      │
+│  query.parameters → bound values    │
+│  query.schema     → column metadata │
+└─────────────────────────────────────┘
+```
+
+## Factory Pattern
+
+FoxHound uses a factory constructor pattern.  The module exports a bare constructor; you create instances by calling `.new()` with a Fable service context:
+
+```javascript
+var libFoxHound = require('foxhound');
+var tmpQuery = libFoxHound.new(_Fable);
+```
+
+Every query instance gets its own UUID and independent parameter state, so multiple queries can be built concurrently without interference.
+
+## Parameters Object
+
+All query state lives in a single `Parameters` object:
+
+| Property | Type | Purpose |
+|----------|------|---------|
+| `scope` | String | Table or collection name |
+| `dataElements` | Array | Column/field list |
+| `begin` | Integer | Pagination start offset |
+| `cap` | Integer | Maximum rows to return |
+| `filter` | Array | Filter expression objects |
+| `sort` | Array | Sort expression objects |
+| `join` | Array | Join expression objects |
+| `query` | Object | Generated query body, schema, records, and bound parameters |
+| `queryOverride` | String | Custom query template |
+| `indexHints` | Array | Index hints for the database engine |
+| `userID` | Integer | The acting user (for audit stamps) |
+| `result` | Object | Execution results (value, error, executed flag) |
+
+## Dialect Strategy
+
+Each dialect is a module that exports a factory function accepting a Fable instance.  The returned object exposes six methods that each accept a Parameters object and return a SQL string:
+
+- `Create(pParameters)` — INSERT statement
+- `Read(pParameters)` — SELECT statement
+- `Update(pParameters)` — UPDATE statement
+- `Delete(pParameters)` — UPDATE (soft) or DELETE (hard)
+- `Undelete(pParameters)` — UPDATE to restore soft-deleted rows
+- `Count(pParameters)` — SELECT COUNT statement
+
+The dialect handles all syntax differences: quoting identifiers, parameter prefixes, pagination syntax, date functions, and identity column handling.
+
+## Chainable API
+
+Every setter method returns `this`, enabling fluent composition:
+
+```javascript
+tmpQuery
+    .setScope('Orders')
+    .setDataElements(['OrderID', 'Total', 'Status'])
+    .addFilter('Status', 'Pending')
+    .addSort({Column: 'Total', Direction: 'Descending'})
+    .setCap(50)
+    .setDialect('MySQL')
+    .buildReadQuery();
+```
+
+## Fable Integration
+
+FoxHound depends on Fable for:
+
+- **UUID Generation** — each query and record gets a unique identifier via `_Fable.getUUID()`
+- **Logging** — filter, scope, and query errors are logged through `_Fable.log`
+- **Utility Functions** — `_Fable.Utility.extend()` for parameter merging and `_Fable.Utility.template()` for query overrides
+- **Configuration** — inherits any relevant settings from the Fable config

package/docs/configuration.md

@@ -0,0 +1,217 @@
+# Configuration Reference
+
+This page documents all FoxHound configuration methods, properties, and their accepted values.
+
+## Query Configuration Methods
+
+All setter methods return `this` for chaining.
+
+### setScope(pScope)
+
+Set the primary table or collection for the query.
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `pScope` | String | Table name |
+
+```javascript
+tmpQuery.setScope('Books');
+```
+
+### setDialect(pDialectName)
+
+Set the SQL dialect for query generation.
+
+| Parameter | Type | Values |
+|-----------|------|--------|
+| `pDialectName` | String | `'MySQL'`, `'MSSQL'`, `'SQLite'`, `'ALASQL'`, `'English'`, `'MeadowEndpoints'` |
+
+```javascript
+tmpQuery.setDialect('MySQL');
+```
+
+### setDataElements(pDataElements)
+
+Set the columns to select.  Pass `false` or omit to select all columns (`*`).
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `pDataElements` | Array or String | Column name(s) |
+
+```javascript
+tmpQuery.setDataElements(['Title', 'Author']);
+tmpQuery.setDataElements('Title'); // Wraps in array automatically
+```
+
+### setDistinct(pDistinct)
+
+Enable or disable DISTINCT results.
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `pDistinct` | Boolean | `true` to enable DISTINCT |
+
+### setBegin(pBeginAmount)
+
+Set the pagination starting offset.
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `pBeginAmount` | Integer ≥ 0 | Zero-based row offset |
+
+### setCap(pCapAmount)
+
+Set the maximum number of rows to return.
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `pCapAmount` | Integer ≥ 0 | Maximum row count |
+
+### addFilter(pColumn, pValue, pOperator, pConnector, pParameter)
+
+Add a filter expression.
+
+| Parameter | Default | Description |
+|-----------|---------|-------------|
+| `pColumn` | *(required)* | Column name |
+| `pValue` | *(required)* | Comparison value |
+| `pOperator` | `'='` | Operator (`=`, `!=`, `>`, `>=`, `<`, `<=`, `LIKE`, `IN`, `NOT IN`, `IS NULL`, `IS NOT NULL`, `(`, `)`) |
+| `pConnector` | `'AND'` | Logical connector (`AND`, `OR`, `NONE`) |
+| `pParameter` | `pColumn` | Parameter name |
+
+### setFilter(pFilter)
+
+Replace the entire filter array.
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `pFilter` | Array or Object | Filter expression(s) |
+
+### addSort(pSort)
+
+Add a sort expression.
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `pSort` | String or Object | Column name or `{Column, Direction}` |
+
+### setSort(pSort)
+
+Replace the entire sort array.
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `pSort` | String, Object, or Array | Sort expression(s) |
+
+### addJoin(pTable, pFrom, pTo, pType)
+
+Add a join expression.
+
+| Parameter | Default | Description |
+|-----------|---------|-------------|
+| `pTable` | *(required)* | Table to join |
+| `pFrom` | *(required)* | Column on join table |
+| `pTo` | *(required)* | Column on base table |
+| `pType` | `'INNER JOIN'` | Join type |
+
+### setJoin(pJoin)
+
+Replace the entire join array.
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `pJoin` | Object or Array | Join expression(s) |
+
+### addRecord(pRecord)
+
+Add a record for CREATE or UPDATE operations.
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `pRecord` | Object | Key-value pairs of column names and values |
+
+### setIDUser(pIDUser)
+
+Set the user ID for audit stamp columns.
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `pIDUser` | Integer ≥ 0 | User ID |
+
+### setDisableAutoIdentity(pFlag)
+
+Disable automatic identity column handling.
+
+### setDisableAutoDateStamp(pFlag)
+
+Disable automatic timestamp generation.
+
+### setDisableAutoUserStamp(pFlag)
+
+Disable automatic user ID stamping.
+
+### setDisableDeleteTracking(pFlag)
+
+Disable soft-delete behavior.
+
+### setLogLevel(pLogLevel)
+
+Set the query logging verbosity.
+
+| Level | Behavior |
+|-------|----------|
+| `0` | No logging (default) |
+| `1` | Log generated queries |
+| `2` | Log queries and non-parameterized versions |
+| `3` | Log everything |
+
+## Properties
+
+| Property | Type | Access | Description |
+|----------|------|--------|-------------|
+| `query` | Object | get/set | The generated query (`body`, `schema`, `records`, `parameters`) |
+| `result` | Object | get/set | Execution results (`executed`, `value`, `error`) |
+| `parameters` | Object | get/set | Full parameters state |
+| `dialect` | Object | get | Current dialect object |
+| `uuid` | String | get | Unique identifier for this query |
+| `logLevel` | Integer | get | Current log level |
+| `indexHints` | Array | get/set | Index hints for the database engine |
+
+## Utility Methods
+
+### clone()
+
+Create a new FoxHound query with the same scope, begin, cap, schema, dataElements, sorts, and filters.
+
+```javascript
+var tmpClone = tmpQuery.clone();
+```
+
+### resetParameters()
+
+Reset the query to its default state.
+
+```javascript
+tmpQuery.resetParameters();
+```
+
+### mergeParameters(pFromParameters)
+
+Merge an object of parameters into the current state.
+
+```javascript
+tmpQuery.mergeParameters({cap: 50, begin: 0});
+```
+
+## Build Methods
+
+| Method | Generates |
+|--------|-----------|
+| `buildCreateQuery()` | INSERT statement |
+| `buildReadQuery()` | SELECT statement |
+| `buildUpdateQuery()` | UPDATE statement |
+| `buildDeleteQuery()` | DELETE or soft-delete UPDATE |
+| `buildUndeleteQuery()` | Restore soft-deleted rows |
+| `buildCountQuery()` | SELECT COUNT statement |
+
+All build methods return `this` for chaining.  The generated SQL is available at `query.body` and bound parameters at `query.parameters`.

package/docs/cover.md

@@ -0,0 +1,11 @@
+# FoxHound <small>2</small>
+
+> A fluent query generation DSL for Node.js and the browser
+
+- Chainable API that generates dialect-specific SQL
+- Parameterized queries for safe, injection-free operation
+- Schema-aware with automatic identity, timestamp, and soft-delete management
+- Multiple dialects: MySQL, MSSQL, SQLite, ALASQL, and more
+
+[GitHub](https://github.com/stevenvelozo/foxhound)
+[Get Started](#foxhound)

package/docs/dialects/README.md

@@ -0,0 +1,61 @@
+# Dialects Overview
+
+FoxHound uses a dialect strategy pattern to generate database-specific SQL from the same query configuration.  Each dialect is a self-contained module that translates FoxHound's internal parameters into the target SQL syntax.
+
+## Available Dialects
+
+| Dialect | Target | Identifier Quoting | Parameter Prefix | Pagination |
+|---------|--------|-------------------|-----------------|------------|
+| [MySQL](dialects/mysql.md) | MySQL / MariaDB | `` `backticks` `` | `:name` | `LIMIT offset, count` |
+| [MSSQL](dialects/mssql.md) | Microsoft SQL Server | `[brackets]` | `@name` | `OFFSET n ROWS FETCH NEXT m ROWS ONLY` |
+| [SQLite](dialects/sqlite.md) | SQLite 3 | `` `backticks` `` | `:name` | `LIMIT count OFFSET offset` |
+| [ALASQL](dialects/alasql.md) | ALASQL (in-memory) | `` `backticks` `` | `:name` | `LIMIT count FETCH offset` |
+| English | Human-readable | none | none | prose |
+| MeadowEndpoints | REST URL generation | none | none | query string |
+
+## Setting a Dialect
+
+```javascript
+tmpQuery.setDialect('MySQL');
+```
+
+If no dialect is set before building a query, FoxHound defaults to `English`.
+
+If an invalid dialect name is passed, FoxHound logs an error and falls back to `English`.
+
+## Dialect Interface
+
+Every dialect exports a factory function that accepts a Fable instance and returns an object with six methods:
+
+```javascript
+{
+    Create: function(pParameters) { ... },
+    Read:   function(pParameters) { ... },
+    Update: function(pParameters) { ... },
+    Delete: function(pParameters) { ... },
+    Undelete: function(pParameters) { ... },
+    Count:  function(pParameters) { ... }
+}
+```
+
+Each method receives the full Parameters object and returns a SQL string (or `false` if the query cannot be generated).
+
+## Common Behaviors
+
+All SQL dialects share these behaviors:
+
+- **Parameterized values** — user data is always bound as named parameters, never interpolated
+- **Schema-aware column management** — AutoIdentity, timestamps, user stamps, and soft-delete columns are handled automatically based on schema type annotations
+- **Soft-delete filtering** — Read and Count queries automatically exclude rows where the `Deleted` column is `1` (when schema is present)
+- **Query overrides** — Read and Count queries support underscore templates for custom SQL generation
+
+## Choosing a Dialect
+
+| Use Case | Recommended Dialect |
+|----------|-------------------|
+| Production MySQL/MariaDB | `MySQL` |
+| Production SQL Server | `MSSQL` |
+| Embedded/file-based database | `SQLite` |
+| Browser-side or in-memory queries | `ALASQL` |
+| Debugging/logging | `English` |
+| REST API URL generation | `MeadowEndpoints` |