meadow-connection-mssql 1.0.11 → 1.0.13

package/README.md

@@ -10,13 +10,14 @@ A Microsoft SQL Server connection provider for the Meadow ORM. Wraps [mssql](htt
 
 ## Features
 
-- **MSSQL Connection Pooling** - Managed connection pool via [mssql](https://github.com/tediousjs/node-mssql) (Tedious driver)
-- **Fable Service Provider** - Registers with a Fable instance for dependency injection, logging, and configuration
-- **Async Connection** - Truly asynchronous connection flow with promise-based pool creation and callback interface
-- **Prepared Statements** - Built-in `preparedStatement` getter for creating parameterized queries against the pool
-- **Schema-Driven DDL** - Generates `CREATE TABLE` statements with `[dbo]` schema prefix, `IDENTITY` primary keys, and proper MSSQL column types
-- **Connection Safety** - Guards against duplicate connection pools with descriptive logging (passwords are never leaked)
-- **Configurable Timeouts** - Request timeout (80s) and connection timeout (80s) with pool idle timeout (30s) defaults
+- **MSSQL Connection Pooling** -- Managed connection pool via [mssql](https://github.com/tediousjs/node-mssql) (Tedious driver)
+- **Fable Service Provider** -- Registers with a Fable instance for dependency injection, logging, and configuration
+- **Async Connection** -- Truly asynchronous connection flow with promise-based pool creation and callback interface
+- **Prepared Statements** -- Built-in `preparedStatement` getter for creating parameterized queries against the pool
+- **Direct Driver Access** -- `MSSQL` getter exposes the raw `mssql` package for type constants (`Int`, `VarChar`, `Decimal`, etc.)
+- **Schema-Driven DDL** -- Generates `CREATE TABLE` statements with `[dbo]` schema prefix, `IDENTITY` primary keys, and proper MSSQL column types
+- **Connection Safety** -- Guards against duplicate connection pools with descriptive logging (passwords are never leaked)
+- **Configurable Timeouts** -- Request timeout (80s) and connection timeout (80s) with pool idle timeout (30s) defaults
 
 ## Installation
 
@@ -171,13 +172,13 @@ Generate a safe `DROP TABLE` statement using `IF OBJECT_ID` to check existence b
 
 Meadow Connection MSSQL is a database connector for the Meadow data access layer:
 
-- [meadow](https://github.com/stevenvelozo/meadow) - ORM and data access framework
-- [foxhound](https://github.com/stevenvelozo/foxhound) - Query DSL used by Meadow
-- [stricture](https://github.com/stevenvelozo/stricture) - Schema definition tool
-- [meadow-endpoints](https://github.com/stevenvelozo/meadow-endpoints) - RESTful endpoint generation
-- [meadow-connection-mysql](https://github.com/stevenvelozo/meadow-connection-mysql) - MySQL connector
-- [meadow-connection-sqlite](https://github.com/stevenvelozo/meadow-connection-sqlite) - SQLite connector
-- [fable](https://github.com/stevenvelozo/fable) - Application services framework
+- [meadow](https://github.com/stevenvelozo/meadow) -- ORM and data access framework
+- [foxhound](https://github.com/stevenvelozo/foxhound) -- Query DSL used by Meadow
+- [stricture](https://github.com/stevenvelozo/stricture) -- Schema definition tool
+- [meadow-endpoints](https://github.com/stevenvelozo/meadow-endpoints) -- RESTful endpoint generation
+- [meadow-connection-mysql](https://github.com/stevenvelozo/meadow-connection-mysql) -- MySQL connector
+- [meadow-connection-sqlite](https://github.com/stevenvelozo/meadow-connection-sqlite) -- SQLite connector
+- [fable](https://github.com/stevenvelozo/fable) -- Application services framework
 
 ## Testing
 
@@ -195,8 +196,10 @@ npm run coverage
 
 ## Related Packages
 
-- [meadow](https://github.com/stevenvelozo/meadow) - Data access and ORM
-- [fable](https://github.com/stevenvelozo/fable) - Application services framework
+- [meadow](https://github.com/stevenvelozo/meadow) -- Data access and ORM
+- [meadow-connection-mysql](https://github.com/stevenvelozo/meadow-connection-mysql) -- MySQL connection provider
+- [meadow-connection-rocksdb](https://github.com/stevenvelozo/meadow-connection-rocksdb) -- RocksDB connection provider
+- [fable](https://github.com/stevenvelozo/fable) -- Application services framework
 
 ## License
 

package/docs/README.md

@@ -131,9 +131,29 @@ The `MSSQL` getter exposes the underlying `mssql` package for accessing type con
 
 The service can generate and execute CREATE TABLE statements from Meadow schema definitions. See [Schema & Table Creation](schema.md) for details.
 
+## How It Fits Together
+
+```
+Application Code
+        |
+    Meadow ORM   ← setProvider('MSSQL')
+        |
+    FoxHound      ← Generates SQL queries
+        |
+    Meadow-Connection-MSSQL   ← This module
+        |
+    mssql Pool    ← Connection pooling, Tedious driver
+        |
+    SQL Server    ← Your database
+```
+
+Meadow Connection MSSQL sits between the Meadow ORM layer and the SQL Server. It manages the mssql connection pool, which Meadow's MSSQL provider uses to execute queries generated by FoxHound. The module also exposes prepared statements and the raw mssql library for direct use.
+
 ## Learn More
 
+- [Quickstart](quickstart.md) -- Step-by-step walkthrough with code examples
+- [Architecture](architecture.md) -- Design, data flow, and component responsibilities
 - [Schema & Table Creation](schema.md) -- Generate MSSQL tables from Meadow schemas
-- [API Reference](api.md) -- Complete method and property documentation
+- [API Reference](api/reference.md) -- Complete method and property documentation
 - [Meadow](/meadow/meadow/) -- The data access layer
 - [FoxHound](/meadow/foxhound/) -- Query DSL used by Meadow

package/docs/_cover.md

@@ -0,0 +1,21 @@
+# Meadow Connection MSSQL
+
+<small>v1.0.11</small>
+
+> Microsoft SQL Server connection pooling as a Fable service
+
+A wrapper around the [mssql](https://github.com/tediousjs/node-mssql) npm package (Tedious driver) that manages connection pooling, prepared statements, and schema DDL generation. Register once, query from anywhere through Meadow or directly.
+
+- **Async Connection** -- Promise-based pool creation with callback notification when ready
+- **Connection Pooling** -- Managed pool with configurable timeouts and connection limits
+- **Prepared Statements** -- First-class access to parameterized queries with MSSQL type constants
+- **Direct Driver Access** -- `MSSQL` getter exposes the raw mssql package for type constants
+- **Schema-Driven DDL** -- Generate CREATE TABLE statements with `[dbo]` schema and IDENTITY keys
+- **Connection Safety** -- Guards against duplicate pools with cleansed logging
+
+[Get Started](README.md)
+[Quickstart](quickstart.md)
+[Architecture](architecture.md)
+[Schema & Tables](schema.md)
+[API Reference](api/reference.md)
+[GitHub](https://github.com/stevenvelozo/meadow-connection-mssql)

package/docs/_sidebar.md

@@ -1,11 +1,25 @@
 - Getting Started
 
   - [Overview](README.md)
+  - [Quickstart](quickstart.md)
+
+- Architecture
+
+  - [Design & Data Flow](architecture.md)
   - [Schema & Table Creation](schema.md)
 
-- Reference
+- API Reference
 
-  - [API Reference](api.md)
+  - [Full Reference](api/reference.md)
+  - [connectAsync()](api/connectAsync.md)
+  - [connect()](api/connect.md)
+  - [pool](api/pool.md)
+  - [preparedStatement](api/preparedStatement.md)
+  - [MSSQL](api/MSSQL.md)
+  - [generateCreateTableStatement()](api/generateCreateTableStatement.md)
+  - [createTable()](api/createTable.md)
+  - [createTables()](api/createTables.md)
+  - [generateDropTableStatement()](api/generateDropTableStatement.md)
 
 - Retold Ecosystem
 
@@ -13,4 +27,7 @@
   - [FoxHound](/meadow/foxhound/)
   - [Stricture](/meadow/stricture/)
   - [Meadow Endpoints](/meadow/meadow-endpoints/)
+  - [Meadow Connection MySQL](/meadow/meadow-connection-mysql/)
+  - [Meadow Connection SQLite](/meadow/meadow-connection-sqlite/)
+  - [Meadow Connection RocksDB](/meadow/meadow-connection-rocksdb/)
   - [Fable](/fable/fable/)

package/docs/_topbar.md

@@ -1,6 +1,8 @@
 # Meadow Connection MSSQL
 
 - [Overview](README.md)
+- [Quickstart](quickstart.md)
+- [Architecture](architecture.md)
 - [Schema & Tables](schema.md)
-- [API Reference](api.md)
+- [API Reference](api/reference.md)
 - [GitHub](https://github.com/stevenvelozo/meadow-connection-mssql)

package/docs/api/MSSQL.md

@@ -0,0 +1,112 @@
+# MSSQL (getter)
+
+Returns the underlying `mssql` npm package module for direct access to SQL Server type constants and driver features.
+
+## Signature
+
+```javascript
+get MSSQL()
+```
+
+## Return Value
+
+| Type | Description |
+|------|-------------|
+| object | The `mssql` npm module |
+
+## Primary Use
+
+The main purpose of this getter is to access type constants for prepared statement parameters:
+
+```javascript
+let tmpPS = _Fable.MeadowMSSQLProvider.preparedStatement;
+
+tmpPS.input('bookId', _Fable.MeadowMSSQLProvider.MSSQL.Int);
+tmpPS.input('title', _Fable.MeadowMSSQLProvider.MSSQL.VarChar(255));
+tmpPS.input('price', _Fable.MeadowMSSQLProvider.MSSQL.Decimal(10, 2));
+```
+
+## Type Constants Reference
+
+### Integer Types
+
+| Constant | SQL Server Type | Range |
+|----------|----------------|-------|
+| `MSSQL.Int` | `INT` | -2^31 to 2^31-1 |
+| `MSSQL.BigInt` | `BIGINT` | -2^63 to 2^63-1 |
+| `MSSQL.SmallInt` | `SMALLINT` | -32,768 to 32,767 |
+| `MSSQL.TinyInt` | `TINYINT` | 0 to 255 |
+
+### String Types
+
+| Constant | SQL Server Type | Description |
+|----------|----------------|-------------|
+| `MSSQL.VarChar(n)` | `VARCHAR(n)` | Variable-length non-Unicode string |
+| `MSSQL.NVarChar(n)` | `NVARCHAR(n)` | Variable-length Unicode string |
+| `MSSQL.Char(n)` | `CHAR(n)` | Fixed-length non-Unicode string |
+| `MSSQL.NChar(n)` | `NCHAR(n)` | Fixed-length Unicode string |
+| `MSSQL.Text` | `TEXT` | Large non-Unicode text |
+| `MSSQL.NText` | `NTEXT` | Large Unicode text |
+
+### Numeric Types
+
+| Constant | SQL Server Type | Description |
+|----------|----------------|-------------|
+| `MSSQL.Decimal(p, s)` | `DECIMAL(p,s)` | Fixed precision and scale |
+| `MSSQL.Float` | `FLOAT` | Approximate numeric |
+
+### Date/Time Types
+
+| Constant | SQL Server Type | Description |
+|----------|----------------|-------------|
+| `MSSQL.DateTime` | `DATETIME` | Date and time (3.33ms precision) |
+| `MSSQL.DateTime2(s)` | `DATETIME2(s)` | Higher precision date/time |
+| `MSSQL.Date` | `DATE` | Date only |
+| `MSSQL.Time` | `TIME` | Time only |
+
+### Other Types
+
+| Constant | SQL Server Type | Description |
+|----------|----------------|-------------|
+| `MSSQL.Bit` | `BIT` | Boolean (0 or 1) |
+
+## Usage with Prepared Statements
+
+```javascript
+let tmpMSSQL = _Fable.MeadowMSSQLProvider.MSSQL;
+let tmpPS = _Fable.MeadowMSSQLProvider.preparedStatement;
+
+tmpPS.input('id', tmpMSSQL.Int);
+tmpPS.input('name', tmpMSSQL.VarChar(200));
+tmpPS.input('price', tmpMSSQL.Decimal(10, 2));
+tmpPS.input('published', tmpMSSQL.DateTime);
+tmpPS.input('active', tmpMSSQL.Bit);
+
+tmpPS.prepare(
+	'INSERT INTO Product ([Name], [Price], [PublishDate], [Active]) VALUES (@name, @price, @published, @active); SELECT SCOPE_IDENTITY() AS ID',
+	(pError) =>
+	{
+		if (pError) { return; }
+
+		tmpPS.execute(
+			{
+				name: 'Widget',
+				price: 19.99,
+				published: new Date(),
+				active: true
+			},
+			(pError, pResult) =>
+			{
+				if (!pError)
+				{
+					console.log(`Inserted ID: ${pResult.recordset[0].ID}`);
+				}
+				tmpPS.unprepare(() => {});
+			});
+	});
+```
+
+## Related
+
+- [preparedStatement](preparedStatement.md) -- Create prepared statements that use these types
+- [pool](pool.md) -- Direct query access

package/docs/api/connect.md

@@ -0,0 +1,74 @@
+# connect()
+
+Synchronous convenience wrapper that calls `connectAsync()` without a callback.
+
+> **Warning:** This method is **not recommended** because the MSSQL driver requires an asynchronous connection handshake. Using `connect()` can cause race conditions where queries are executed before the pool is ready. Always prefer [connectAsync()](connectAsync.md).
+
+## Signature
+
+```javascript
+connect()
+```
+
+## Parameters
+
+None.
+
+## Return Value
+
+None.
+
+## Behavior
+
+1. Logs a warning: "The non-async Meadow-MSSQL connect() was called and the Microsoft SQL node driver has an asynchronous connection method; although this may function it will likely cause a race condition."
+2. Calls `this.connectAsync()` internally without passing a callback
+
+## Usage
+
+```javascript
+// NOT recommended -- use connectAsync() instead
+_Fable.MeadowMSSQLProvider.connect();
+
+// The pool may not be ready yet -- race condition!
+// _Fable.MeadowMSSQLProvider.pool.query(...) // might fail
+```
+
+## Why It Exists
+
+This method exists for API symmetry with other Meadow connection providers (MySQL, SQLite) that support synchronous connection. The `MeadowConnectionMSSQLAutoConnect` flag calls `connect()` during construction, which allows a one-liner instantiation pattern:
+
+```javascript
+let _Fable = new libFable(
+	{
+		"MSSQL":
+		{
+			"server": "localhost",
+			"port": 1433,
+			"user": "sa",
+			"password": "YourPassword123",
+			"database": "bookstore",
+			"MeadowConnectionMSSQLAutoConnect": true
+		}
+	});
+
+_Fable.serviceManager.addAndInstantiateServiceType(
+	'MeadowMSSQLProvider', libMeadowConnectionMSSQL);
+
+// Pool is connecting asynchronously -- not guaranteed to be ready yet
+```
+
+## Recommended Alternative
+
+```javascript
+_Fable.MeadowMSSQLProvider.connectAsync(
+	(pError, pPool) =>
+	{
+		if (pError) return console.error(pError);
+		// Pool is guaranteed to be ready here
+	});
+```
+
+## Related
+
+- [connectAsync](connectAsync.md) -- Async connection (recommended)
+- [pool](pool.md) -- Access the connection pool

package/docs/api/connectAsync.md

@@ -0,0 +1,112 @@
+# connectAsync(fCallback)
+
+Asynchronously establishes a connection pool to Microsoft SQL Server. This is the **recommended** connection method -- MSSQL connections are inherently asynchronous due to the TDS protocol handshake.
+
+## Signature
+
+```javascript
+connectAsync(fCallback)
+```
+
+## Parameters
+
+| Parameter | Type | Required | Description |
+|-----------|------|----------|-------------|
+| `fCallback` | function | Yes | Callback with signature `(pError, pConnectionPool)` |
+
+## Return Value
+
+None (result provided via callback).
+
+## Callback Arguments
+
+| Argument | Type | Description |
+|----------|------|-------------|
+| `pError` | Error or null | Connection error, if any |
+| `pConnectionPool` | mssql Pool | The connected mssql pool instance |
+
+## Behavior
+
+1. If `fCallback` is not a function, logs an error and substitutes a no-op callback
+2. If a pool already exists (`this._ConnectionPool` is truthy):
+   - Logs an error with cleansed connection details (password masked)
+   - Returns the existing pool via the callback (prevents duplicate connections)
+3. If not connected:
+   - Logs the connection attempt details (server, port, user, database, pool limit)
+   - Calls `mssql.connect()` with the resolved settings (Promise-based)
+   - Applies hardcoded pool, timeout, and TLS settings
+   - On success: sets `connected = true`, logs success, calls callback with `(null, pool)`
+   - On error: logs the error, calls callback with `(error)`
+
+## Basic Usage
+
+```javascript
+const libFable = require('fable');
+const libMeadowConnectionMSSQL = require('meadow-connection-mssql');
+
+let _Fable = new libFable(
+	{
+		"MSSQL":
+		{
+			"server": "localhost",
+			"port": 1433,
+			"user": "sa",
+			"password": "YourPassword123",
+			"database": "bookstore"
+		}
+	});
+
+_Fable.serviceManager.addServiceType('MeadowMSSQLProvider', libMeadowConnectionMSSQL);
+_Fable.serviceManager.instantiateServiceProvider('MeadowMSSQLProvider');
+
+_Fable.MeadowMSSQLProvider.connectAsync(
+	(pError, pPool) =>
+	{
+		if (pError)
+		{
+			console.error('Connection failed:', pError);
+			return;
+		}
+
+		// pPool is the mssql connection pool
+		pPool.query('SELECT TOP 5 * FROM Book')
+			.then((pResult) =>
+			{
+				console.log(`Found ${pResult.recordset.length} books.`);
+			});
+	});
+```
+
+## Double-Connect Guard
+
+Calling `connectAsync()` a second time returns the existing pool without creating a new one:
+
+```javascript
+_Fable.MeadowMSSQLProvider.connectAsync(
+	(pError, pPool1) =>
+	{
+		// First call -- pool created
+
+		_Fable.MeadowMSSQLProvider.connectAsync(
+			(pError, pPool2) =>
+			{
+				// Second call -- logs error, returns existing pool
+				// "already established a connection"
+			});
+	});
+```
+
+## Missing Callback Warning
+
+If called without a callback, `connectAsync()` logs an error:
+
+```javascript
+// Not recommended
+_Fable.MeadowMSSQLProvider.connectAsync();
+// Logs error about missing callback
+```
+
+## Related
+
+- [connect](connect.md) -- Synchronous wrapper (not recommended)
+- [pool](pool.md) -- Access the connection pool

package/docs/api/createTable.md

@@ -0,0 +1,96 @@
+# createTable(pMeadowTableSchema, fCallback)
+
+Generates and executes a `CREATE TABLE` statement against the connected MSSQL pool.
+
+## Signature
+
+```javascript
+createTable(pMeadowTableSchema, fCallback)
+```
+
+## Parameters
+
+| Parameter | Type | Required | Description |
+|-----------|------|----------|-------------|
+| `pMeadowTableSchema` | object | Yes | Schema with `TableName` and `Columns` array |
+| `fCallback` | function | Yes | Callback with signature `(pError)` |
+
+## Return Value
+
+None (result provided via callback).
+
+## Behavior
+
+1. Calls `generateCreateTableStatement(pMeadowTableSchema)` to produce the DDL string
+2. Executes via `this._ConnectionPool.query()` (Promise-based)
+3. On success:
+   - Logs info: "Meadow-MSSQL CREATE TABLE [TableName] Success"
+   - Logs warning with the full SQL statement
+   - Calls `fCallback()` with no error
+4. On error:
+   - Checks if the error indicates the table already exists (via `originalError.info.message`)
+   - If table exists: silently succeeds, calls `fCallback()` with no error
+   - Otherwise: logs the error, calls `fCallback(pError)`
+
+## Basic Usage
+
+```javascript
+let tmpSchema =
+{
+	TableName: 'Book',
+	Columns:
+	[
+		{ Column: 'IDBook', DataType: 'ID' },
+		{ Column: 'GUIDBook', DataType: 'GUID' },
+		{ Column: 'Title', DataType: 'String', Size: 255 },
+		{ Column: 'Author', DataType: 'String', Size: 128 },
+		{ Column: 'Year', DataType: 'Numeric' }
+	]
+};
+
+_Fable.MeadowMSSQLProvider.createTable(tmpSchema,
+	(pError) =>
+	{
+		if (pError)
+		{
+			console.error('Table creation failed:', pError);
+			return;
+		}
+		console.log('Book table created successfully.');
+	});
+```
+
+## Idempotent Operation
+
+Calling `createTable()` for an existing table does not produce an error. The "table already exists" error is caught internally and execution continues:
+
+```
+// No error -- table simply already existed
+```
+
+This makes `createTable()` safe to call during application startup.
+
+## Prerequisites
+
+The connection pool must be established before calling `createTable()`:
+
+```javascript
+_Fable.MeadowMSSQLProvider.connectAsync(
+	(pError) =>
+	{
+		if (pError) { return; }
+
+		_Fable.MeadowMSSQLProvider.createTable(tmpSchema,
+			(pCreateError) =>
+			{
+				if (pCreateError) { console.error(pCreateError); }
+			});
+	});
+```
+
+## Related
+
+- [generateCreateTableStatement](generateCreateTableStatement.md) -- Generate DDL without executing
+- [createTables](createTables.md) -- Create multiple tables sequentially
+- [generateDropTableStatement](generateDropTableStatement.md) -- Generate DROP TABLE DDL
+- [Schema & Table Creation](../schema.md) -- Full walkthrough

package/docs/api/createTables.md

@@ -0,0 +1,111 @@
+# createTables(pMeadowSchema, fCallback)
+
+Creates all tables defined in a Meadow schema object by calling `createTable()` for each table sequentially.
+
+## Signature
+
+```javascript
+createTables(pMeadowSchema, fCallback)
+```
+
+## Parameters
+
+| Parameter | Type | Required | Description |
+|-----------|------|----------|-------------|
+| `pMeadowSchema` | object | Yes | Schema with a `Tables` array of table schema objects |
+| `fCallback` | function | Yes | Callback with signature `(pError)` |
+
+### Schema Object Format
+
+```javascript
+{
+	Tables:
+	[
+		{
+			TableName: 'Author',
+			Columns:
+			[
+				{ Column: 'IDAuthor', DataType: 'ID' },
+				{ Column: 'Name', DataType: 'String', Size: 200 }
+			]
+		},
+		{
+			TableName: 'Book',
+			Columns:
+			[
+				{ Column: 'IDBook', DataType: 'ID' },
+				{ Column: 'Title', DataType: 'String', Size: 255 },
+				{ Column: 'IDAuthor', DataType: 'ForeignKey' }
+			]
+		}
+	]
+}
+```
+
+## Return Value
+
+None (result provided via callback).
+
+## Behavior
+
+1. Iterates `pMeadowSchema.Tables` using `fable.Utility.eachLimit()` with a concurrency of 1 (serial)
+2. Calls `createTable()` for each table in the array
+3. If any table creation fails (with an error other than "already exists"), logs the error and passes it to the final callback
+4. On completion, logs "Done creating tables!" and calls `fCallback()`
+
+## Basic Usage
+
+```javascript
+let tmpFullSchema =
+{
+	Tables:
+	[
+		{
+			TableName: 'Author',
+			Columns:
+			[
+				{ Column: 'IDAuthor', DataType: 'ID' },
+				{ Column: 'GUIDAuthor', DataType: 'GUID' },
+				{ Column: 'Name', DataType: 'String', Size: 200 },
+				{ Column: 'Bio', DataType: 'Text' }
+			]
+		},
+		{
+			TableName: 'Book',
+			Columns:
+			[
+				{ Column: 'IDBook', DataType: 'ID' },
+				{ Column: 'GUIDBook', DataType: 'GUID' },
+				{ Column: 'Title', DataType: 'String', Size: 255 },
+				{ Column: 'Year', DataType: 'Numeric' },
+				{ Column: 'IDAuthor', DataType: 'ForeignKey' }
+			]
+		}
+	]
+};
+
+_Fable.MeadowMSSQLProvider.createTables(tmpFullSchema,
+	(pError) =>
+	{
+		if (pError)
+		{
+			console.error('Schema creation failed:', pError);
+			return;
+		}
+		console.log('All tables created.');
+	});
+```
+
+## Serial Execution
+
+Tables are created one at a time (concurrency of 1). This respects dependency ordering and avoids concurrent DDL issues with SQL Server.
+
+## Error Handling
+
+If a table creation fails with an error other than "table already exists", execution stops and the error is passed to the callback. Tables created before the failure remain in the database.
+
+## Related
+
+- [createTable](createTable.md) -- Create a single table
+- [generateCreateTableStatement](generateCreateTableStatement.md) -- Generate DDL without executing
+- [Schema & Table Creation](../schema.md) -- Full walkthrough