dbtour-source-mssql 0.2.4 → 0.4.0

package/dist/map.d.ts

@@ -1,8 +1,15 @@
 import type { Database } from 'dbtour';
+/** node-mssql returns a bigint as a string, since it may not fit a JavaScript number. */
+type Count = number | string;
+/** Whether the sensitivity labels were read: the view is absent before SQL Server 2019, or the login may not. */
+type Labels = 'read' | 'denied' | 'absent';
 export interface InfoRow {
     name: string;
     version: string | null;
     description: string | null;
+    readAt?: string | null;
+    collation?: string | null;
+    labels?: Labels | null;
 }
 export interface TableRow {
     schema: string;
@@ -10,6 +17,11 @@ export interface TableRow {
     kind: 'table' | 'view';
     description: string | null;
     definition: string | null;
+    rows?: Count | null;
+    dataBytes?: Count | null;
+    indexBytes?: Count | null;
+    created?: string | null;
+    altered?: string | null;
 }
 export interface ColumnRow {
     schema: string;
@@ -25,6 +37,10 @@ export interface ColumnRow {
     default: string | null;
     computed: string | null;
     description: string | null;
+    collation?: string | null;
+    sparse?: boolean | null;
+    identitySeed?: string | null;
+    identityIncrement?: string | null;
 }
 export interface KeyRow {
     schema: string;
@@ -45,6 +61,8 @@ export interface ForeignKeyRow {
     ordinal: number;
     onDelete: string;
     onUpdate: string;
+    disabled?: boolean | null;
+    untrusted?: boolean | null;
 }
 export interface IndexRow {
     schema: string;
@@ -55,6 +73,9 @@ export interface IndexRow {
     column: string;
     ordinal: number;
     included: boolean;
+    type?: string | null;
+    filter?: string | null;
+    disabled?: boolean | null;
 }
 export interface CheckRow {
     schema: string;
@@ -62,6 +83,73 @@ export interface CheckRow {
     name: string;
     definition: string;
     column: string | null;
+    disabled?: boolean | null;
+    untrusted?: boolean | null;
+}
+/** An extended property and what it is on: `item` is the column, index or constraint. */
+export interface PropertyRow {
+    on: 'database' | 'schema' | 'table' | 'column' | 'index' | 'constraint';
+    schema: string | null;
+    table: string | null;
+    item: string | null;
+    name: string;
+    value: string | null;
+}
+export interface FeatureRow {
+    schema: string;
+    table: string;
+    /** 0 none, 1 a history table, 2 system-versioned. */
+    temporalType: number | null;
+    historySchema: string | null;
+    historyTable: string | null;
+    periodStart: string | null;
+    periodEnd: string | null;
+    memoryOptimised: boolean | null;
+    durability: string | null;
+    ledger: string | null;
+    cdc: boolean | null;
+    changeTracking: number | boolean | null;
+    scheme: string | null;
+    function: string | null;
+    partitionColumn: string | null;
+    partitions: number | null;
+    compression: string | null;
+}
+/** One row per trigger and event it fires on. */
+export interface TriggerRow {
+    schema: string;
+    table: string;
+    name: string;
+    insteadOf: boolean;
+    disabled: boolean;
+    event: string;
+    definition: string | null;
+}
+export interface SecurityRow {
+    schema: string;
+    table: string;
+    policySchema: string;
+    policy: string;
+    enabled: boolean;
+    kind: string;
+    operation: string | null;
+    predicate: string;
+}
+export interface ColumnSecurityRow {
+    schema: string;
+    table: string;
+    column: string;
+    masked: string | null;
+    encryption: string | null;
+    key: string | null;
+}
+export interface SensitivityRow {
+    schema: string;
+    table: string;
+    column: string;
+    label: string | null;
+    informationType: string | null;
+    rank: string | null;
 }
 export interface Recordsets {
     info: InfoRow[];
@@ -71,6 +159,12 @@ export interface Recordsets {
     foreignKeys: ForeignKeyRow[];
     indexes: IndexRow[];
     checks: CheckRow[];
+    properties: PropertyRow[];
+    features: FeatureRow[];
+    triggers: TriggerRow[];
+    security: SecurityRow[];
+    columnSecurity: ColumnSecurityRow[];
+    sensitivity: SensitivityRow[];
 }
 export interface MapOptions {
     /** The name the docs call the database; the server's own name when not given. */
@@ -83,3 +177,4 @@ export declare function toRecordsets(sets: unknown[][]): Recordsets;
 export declare function mapRecordsets(sets: Recordsets, options?: MapOptions): Database;
 /** The type as SQL Server would spell it in a CREATE TABLE: nvarchar(320), varchar(max), decimal(18,2), datetime2(7). */
 export declare function formatType(row: Pick<ColumnRow, 'type' | 'maxLength' | 'precision' | 'scale'>): string;
+export {};

package/dist/map.js

@@ -1,9 +1,9 @@
 /** The result sets in the order query.sql returns them. */
 export function toRecordsets(sets) {
-    if (sets.length !== 7)
-        throw new Error(`query.sql returns 7 result sets, got ${sets.length}: the query and map.ts disagree`);
-    const [info, tables, columns, keys, foreignKeys, indexes, checks] = sets;
-    return { info, tables, columns, keys, foreignKeys, indexes, checks };
+    if (sets.length !== 13)
+        throw new Error(`query.sql returns 13 result sets, got ${sets.length}: the query and map.ts disagree`);
+    const [info, tables, columns, keys, foreignKeys, indexes, checks, properties, features, triggers, security, columnSecurity, sensitivity] = sets;
+    return { info, tables, columns, keys, foreignKeys, indexes, checks, properties, features, triggers, security, columnSecurity, sensitivity };
 }
 export function mapRecordsets(sets, options = {}) {
     const info = sets.info[0];
@@ -22,6 +22,14 @@ export function mapRecordsets(sets, options = {}) {
             table.description = row.description;
         if (row.kind === 'view' && row.definition)
             table.definition = row.definition;
+        // A byte count past 2^53 loses its last digits as a number, which no reader of a size will miss. Only a
+        // table: an indexed view has rows in sys.partitions too, but they are the view's results, not stored data.
+        if (row.kind === 'table' && row.rows !== null && row.rows !== undefined)
+            table.stats = { rows: Number(row.rows), dataBytes: Number(row.dataBytes ?? 0), indexBytes: Number(row.indexBytes ?? 0) };
+        if (row.created)
+            table.created = row.created;
+        if (row.altered)
+            table.altered = row.altered;
         schema.tables.push(table);
         tables.set(`${row.schema}.${row.name}`, table);
     }
@@ -36,8 +44,17 @@ export function mapRecordsets(sets, options = {}) {
             column.computed = row.computed;
         if (row.identity)
             column.identity = true;
+        if (row.identitySeed != null)
+            column.identitySeed = row.identitySeed; // eslint-disable-line eqeqeq
+        if (row.identityIncrement != null)
+            column.identityIncrement = row.identityIncrement; // eslint-disable-line eqeqeq
         if (row.description)
             column.description = row.description;
+        // The database's collation is said once, on the database; a column says its own only when it differs.
+        if (row.collation && row.collation !== info.collation)
+            column.collation = row.collation;
+        if (row.sparse)
+            column.sparse = true;
         table.columns.push(column);
     }
     for (const [key, rows] of groupBy(sets.keys, (r) => `${r.schema}.${r.table}|${r.name}`)) {
@@ -62,8 +79,13 @@ export function mapRecordsets(sets, options = {}) {
             relation.onDelete = first.onDelete;
         if (first.onUpdate && first.onUpdate !== 'NO_ACTION')
             relation.onUpdate = first.onUpdate;
+        const constraint = { name: first.name, kind: 'foreign', columns: relation.from.columns, definition: `${to} (${relation.to.columns.join(', ')})` };
+        if (first.disabled)
+            relation.disabled = constraint.disabled = true;
+        if (first.untrusted)
+            relation.untrusted = constraint.untrusted = true;
         relations.push(relation);
-        tables.get(from).constraints.push({ name: first.name, kind: 'foreign', columns: relation.from.columns, definition: `${to} (${relation.to.columns.join(', ')})` });
+        tables.get(from).constraints.push(constraint);
     }
     for (const [key, rows] of groupBy(sets.indexes, (r) => `${r.schema}.${r.table}|${r.name}`)) {
         const table = tables.get(key.split('|')[0]);
@@ -77,6 +99,12 @@ export function mapRecordsets(sets, options = {}) {
         const included = rows.filter((r) => r.included).map((r) => r.column);
         if (included.length > 0)
             index.included = included;
+        if (rows[0].type)
+            index.type = rows[0].type.toLowerCase().replace(/_/g, ' ');
+        if (rows[0].filter)
+            index.filter = rows[0].filter;
+        if (rows[0].disabled)
+            index.disabled = true;
         table.indexes.push(index);
     }
     for (const row of sets.checks) {
@@ -84,15 +112,141 @@ export function mapRecordsets(sets, options = {}) {
         if (!table)
             continue;
         const constraint = { name: row.name, kind: 'check', columns: row.column ? [row.column] : [], definition: row.definition };
+        if (row.disabled)
+            constraint.disabled = true;
+        if (row.untrusted)
+            constraint.untrusted = true;
         table.constraints.push(constraint);
     }
+    for (const row of sets.features ?? []) {
+        const table = tables.get(`${row.schema}.${row.table}`);
+        if (table)
+            addFeatures(table, row, tables);
+    }
+    for (const [key, rows] of groupBy(sets.triggers ?? [], (r) => `${r.schema}.${r.table}|${r.name}`)) {
+        const table = tables.get(key.split('|')[0]);
+        if (!table)
+            continue;
+        const trigger = { name: rows[0].name, timing: rows[0].insteadOf ? 'instead of' : 'after', events: rows.map((r) => r.event.toLowerCase()), enabled: !rows[0].disabled };
+        if (rows[0].definition)
+            trigger.definition = rows[0].definition;
+        (table.triggers ??= []).push(trigger);
+    }
+    for (const row of sets.security ?? []) {
+        const table = tables.get(`${row.schema}.${row.table}`);
+        if (!table)
+            continue;
+        const predicate = { policy: `${row.policySchema}.${row.policy}`, kind: row.kind === 'BLOCK' ? 'block' : 'filter', predicate: row.predicate, enabled: Boolean(row.enabled) };
+        if (row.operation)
+            predicate.operation = row.operation.toLowerCase();
+        (table.security ??= []).push(predicate);
+    }
+    const columnOf = (schema, table, column) => tables.get(`${schema}.${table}`)?.columns.find((c) => c.name === column);
+    for (const row of sets.columnSecurity ?? []) {
+        const column = columnOf(row.schema, row.table, row.column);
+        if (!column)
+            continue;
+        if (row.masked)
+            column.masked = row.masked;
+        if (row.encryption && row.key)
+            column.encrypted = { type: row.encryption === 'RANDOMIZED' ? 'randomized' : 'deterministic', key: row.key };
+    }
+    for (const row of sets.sensitivity ?? []) {
+        const column = columnOf(row.schema, row.table, row.column);
+        if (!column)
+            continue;
+        const sensitivity = {};
+        if (row.label)
+            sensitivity.label = row.label;
+        if (row.informationType)
+            sensitivity.informationType = row.informationType;
+        if (row.rank && row.rank !== 'NONE')
+            sensitivity.rank = row.rank.toLowerCase();
+        if (Object.keys(sensitivity).length > 0)
+            column.sensitivity = sensitivity;
+    }
     const database = { name: options.name ?? info.name, driver: 'mssql', schemas, relations };
     if (info.version)
         database.version = info.version;
     if (info.description)
         database.description = info.description;
+    if (info.collation)
+        database.collation = info.collation;
+    addProperties(sets.properties ?? [], database, tables);
+    if (info.labels === 'denied')
+        database.unread = ['sensitivity labels: the login lacks VIEW ANY SENSITIVITY CLASSIFICATION'];
+    if (info.readAt && [...tables.values()].some((t) => t.stats))
+        database.statsReadAt = info.readAt;
     return database;
 }
+/** What sys.tables says beyond the structure; a feature the server lacks arrives as NULL and is left out. */
+function addFeatures(table, row, tables) {
+    if (row.temporalType === 2 && row.historySchema && row.historyTable && row.periodStart && row.periodEnd) {
+        const history = `${row.historySchema}.${row.historyTable}`;
+        table.temporal = { history, start: row.periodStart, end: row.periodEnd };
+        const kept = tables.get(history);
+        if (kept)
+            kept.historyOf = `${row.schema}.${row.table}`;
+    }
+    if (row.memoryOptimised)
+        table.memoryOptimised = row.durability === 'SCHEMA_ONLY' ? 'schema only' : 'schema and data';
+    const ledgers = { UPDATABLE_LEDGER_TABLE: 'updatable', APPEND_ONLY_LEDGER_TABLE: 'append-only', HISTORY_TABLE: 'history' };
+    if (row.ledger && ledgers[row.ledger])
+        table.ledger = ledgers[row.ledger];
+    if (row.scheme && row.function && row.partitionColumn) {
+        table.partitioning = { scheme: row.scheme, function: row.function, column: row.partitionColumn, partitions: Number(row.partitions ?? 0) };
+    }
+    // Every partition's setting, comma-separated: one kind is the table's, several are said as a list.
+    const kinds = [...new Set((row.compression ?? '').split(',').map((k) => k.trim().toLowerCase().replace(/_/g, ' ')).filter(Boolean))].sort();
+    if (kinds.length > 1)
+        table.compression = kinds.join(', ');
+    else if (kinds.length === 1 && kinds[0] !== 'none')
+        table.compression = kinds[0];
+    if (row.changeTracking)
+        table.changeTracking = true;
+    if (row.cdc)
+        table.cdc = true;
+}
+/**
+ * Extended properties onto what they describe. MS_Description is the description of a database, table or
+ * column, read apart; on a schema, index or constraint, which have no description, it stays a property.
+ */
+function addProperties(rows, database, tables) {
+    for (const row of rows) {
+        if (row.value === null || row.value === undefined)
+            continue;
+        if (row.name === 'MS_Description' && (row.on === 'database' || row.on === 'table' || row.on === 'column'))
+            continue;
+        const table = row.table ? tables.get(`${row.schema}.${row.table}`) : undefined;
+        let owner;
+        if (row.on === 'database')
+            owner = database;
+        else if (row.on === 'schema')
+            owner = database.schemas.find((s) => s.name === row.schema);
+        else if (row.on === 'table')
+            owner = table;
+        else if (row.on === 'column')
+            owner = table?.columns.find((c) => c.name === row.item);
+        else if (row.on === 'index')
+            owner = table?.indexes.find((i) => i.name === row.item);
+        else
+            owner = table?.constraints.find((c) => c.name === row.item);
+        // A primary key's index is not among the indexes: the constraint stands for it, and keeps its properties.
+        // One the constraint already has under the same name, with another value, is kept beside it.
+        let name = row.name;
+        if (!owner && row.on === 'index') {
+            owner = table?.constraints.find((c) => c.kind === 'primary' && c.name === row.item);
+            if (owner?.properties && Object.hasOwn(owner.properties, name) && owner.properties[name] !== row.value)
+                name = `${name} (index)`;
+        }
+        if (owner)
+            setProperty((owner.properties ??= {}), name, row.value);
+    }
+}
+/** As an own property, so a catalogue name that is also a name of Object's own (__proto__) is kept like any. */
+function setProperty(properties, name, value) {
+    Object.defineProperty(properties, name, { value, enumerable: true, writable: true, configurable: true });
+}
 /** The type as SQL Server would spell it in a CREATE TABLE: nvarchar(320), varchar(max), decimal(18,2), datetime2(7). */
 export function formatType(row) {
     const t = row.type.toLowerCase();

package/dist/query.sql

@@ -1,22 +1,61 @@
--- Everything dbtour needs from SQL Server, in one batch of seven result sets, read in this order by map.ts.
--- Reads the catalogue views only: a login with VIEW DEFINITION on the database is enough.
+-- Everything dbtour needs from SQL Server, in one batch of thirteen result sets, read in this order by map.ts.
+-- Reads the catalogue views only: a login with VIEW DEFINITION on the database is enough. That is why the
+-- sizes come from sys.partitions and sys.allocation_units, catalogue views, rather than
+-- sys.dm_db_partition_stats, which wants VIEW DATABASE STATE and would fail the whole batch without it.
+-- What only newer servers keep (temporal 2016, masking and Always Encrypted 2016, sensitivity labels 2019,
+-- ledger 2022) is read through text the batch assembles after asking whether it exists, so an older server
+-- returns NULL or an empty set there instead of failing. The labels alone want more than VIEW DEFINITION
+-- (VIEW ANY SENSITIVITY CLASSIFICATION); set 1 says whether they were read.
 SET NOCOUNT ON;
 
 -- 1. The database
 SELECT DB_NAME() AS [name],
        CAST(SERVERPROPERTY('ProductVersion') AS nvarchar(50)) AS [version],
-       (SELECT TOP (1) CAST([value] AS nvarchar(max)) FROM sys.extended_properties WHERE class = 0 AND [name] = 'MS_Description') AS [description];
+       (SELECT TOP (1) CAST([value] AS nvarchar(max)) FROM sys.extended_properties WHERE class = 0 AND [name] = 'MS_Description') AS [description],
+       CONVERT(nvarchar(33), SYSUTCDATETIME(), 127) + 'Z' AS [readAt],
+       CAST(DATABASEPROPERTYEX(DB_NAME(), 'Collation') AS nvarchar(128)) AS [collation],
+       CASE WHEN OBJECT_ID('sys.sensitivity_classifications') IS NULL THEN 'absent'
+            WHEN HAS_PERMS_BY_NAME(DB_NAME(), 'DATABASE', 'VIEW ANY SENSITIVITY CLASSIFICATION') = 1 THEN 'read'
+            ELSE 'denied' END AS [labels];
 
--- 2. Tables and views
+-- 2. Tables and views, with each table's rows and bytes as the catalogue counts them (no row is read).
+--    Rows are the heap's or the clustered index's (index_id 0 or 1); data bytes are those pages, index bytes
+--    every other index's. A page is 8 KB. A view has no partitions, so its three are NULL.
 SELECT s.[name] AS [schema],
        o.[name] AS [name],
        CASE o.[type] WHEN 'V' THEN 'view' ELSE 'table' END AS [kind],
        CAST(ep.[value] AS nvarchar(max)) AS [description],
-       m.[definition] AS [definition]
+       m.[definition] AS [definition],
+       -- The server's clock, which is not always UTC: the date is what a reader wants.
+       CONVERT(nvarchar(30), o.create_date, 126) AS [created],
+       CONVERT(nvarchar(30), o.modify_date, 126) AS [altered],
+       r.[rows] AS [rows],
+       b.dataBytes AS [dataBytes],
+       b.indexBytes AS [indexBytes]
 FROM sys.objects o
 JOIN sys.schemas s ON s.schema_id = o.schema_id
 LEFT JOIN sys.extended_properties ep ON ep.class = 1 AND ep.major_id = o.object_id AND ep.minor_id = 0 AND ep.[name] = 'MS_Description'
 LEFT JOIN sys.sql_modules m ON m.object_id = o.object_id
+-- Counted apart: joining the allocation units to the partitions repeats each partition's rows.
+OUTER APPLY (SELECT SUM(p.[rows]) AS [rows] FROM sys.partitions p WHERE p.object_id = o.object_id AND p.index_id IN (0, 1)) r
+OUTER APPLY (
+    SELECT SUM(CASE WHEN u.index_id IN (0, 1) THEN u.used_pages ELSE 0 END) * 8192 AS dataBytes,
+           SUM(CASE WHEN u.index_id > 1 THEN u.used_pages ELSE 0 END) * 8192 AS indexBytes
+    FROM (
+        -- In-row and row-overflow pages belong to the partition's hobt, large-object pages to the partition.
+        SELECT p.index_id, au.used_pages
+        FROM sys.partitions p
+        JOIN sys.allocation_units au ON au.container_id = CASE WHEN au.[type] = 2 THEN p.partition_id ELSE p.hobt_id END
+        WHERE p.object_id = o.object_id
+        UNION ALL
+        -- A columnstore's delta stores, rows not yet compressed, are hobts of their own that sys.partitions
+        -- does not list: their pages are counted with the columnstore index they belong to.
+        SELECT rg.index_id, au.used_pages
+        FROM sys.column_store_row_groups rg
+        JOIN sys.allocation_units au ON au.container_id = rg.delta_store_hobt_id
+        WHERE rg.object_id = o.object_id AND rg.delta_store_hobt_id IS NOT NULL
+    ) u
+) b
 WHERE o.[type] IN ('U', 'V') AND o.is_ms_shipped = 0
 ORDER BY s.[name], o.[name];
 
@@ -33,7 +72,11 @@ SELECT s.[name] AS [schema],
        c.is_identity AS [identity],
        d.[definition] AS [default],
        cc.[definition] AS [computed],
-       CAST(ep.[value] AS nvarchar(max)) AS [description]
+       CAST(ep.[value] AS nvarchar(max)) AS [description],
+       c.collation_name AS [collation],
+       c.is_sparse AS [sparse],
+       CAST(idc.seed_value AS nvarchar(40)) AS [identitySeed],
+       CAST(idc.increment_value AS nvarchar(40)) AS [identityIncrement]
 FROM sys.columns c
 JOIN sys.objects o ON o.object_id = c.object_id AND o.[type] IN ('U', 'V') AND o.is_ms_shipped = 0
 JOIN sys.schemas s ON s.schema_id = o.schema_id
@@ -41,6 +84,7 @@ JOIN sys.types t ON t.user_type_id = c.user_type_id
 LEFT JOIN sys.default_constraints d ON d.object_id = c.default_object_id
 LEFT JOIN sys.computed_columns cc ON cc.object_id = c.object_id AND cc.column_id = c.column_id
 LEFT JOIN sys.extended_properties ep ON ep.class = 1 AND ep.major_id = c.object_id AND ep.minor_id = c.column_id AND ep.[name] = 'MS_Description'
+LEFT JOIN sys.identity_columns idc ON idc.object_id = c.object_id AND idc.column_id = c.column_id
 ORDER BY s.[name], o.[name], c.column_id;
 
 -- 4. Primary keys and unique constraints, one row per column
@@ -67,7 +111,9 @@ SELECT fk.[name] AS [name],
        rc.[name] AS [toColumn],
        fkc.constraint_column_id AS [ordinal],
        fk.delete_referential_action_desc AS [onDelete],
-       fk.update_referential_action_desc AS [onUpdate]
+       fk.update_referential_action_desc AS [onUpdate],
+       fk.is_disabled AS [disabled],
+       fk.is_not_trusted AS [untrusted]
 FROM sys.foreign_keys fk
 JOIN sys.foreign_key_columns fkc ON fkc.constraint_object_id = fk.object_id
 JOIN sys.objects po ON po.object_id = fk.parent_object_id
@@ -86,7 +132,10 @@ SELECT s.[name] AS [schema],
        i.is_primary_key AS [primary],
        c.[name] AS [column],
        ic.key_ordinal AS [ordinal],
-       ic.is_included_column AS [included]
+       ic.is_included_column AS [included],
+       i.type_desc AS [type],
+       i.filter_definition AS [filter],
+       i.is_disabled AS [disabled]
 FROM sys.indexes i
 JOIN sys.objects o ON o.object_id = i.object_id AND o.[type] IN ('U', 'V') AND o.is_ms_shipped = 0
 JOIN sys.schemas s ON s.schema_id = o.schema_id
@@ -100,9 +149,163 @@ SELECT s.[name] AS [schema],
        o.[name] AS [table],
        ck.[name] AS [name],
        ck.[definition] AS [definition],
-       c.[name] AS [column]
+       c.[name] AS [column],
+       ck.is_disabled AS [disabled],
+       ck.is_not_trusted AS [untrusted]
 FROM sys.check_constraints ck
 JOIN sys.objects o ON o.object_id = ck.parent_object_id AND o.is_ms_shipped = 0
 JOIN sys.schemas s ON s.schema_id = o.schema_id
 LEFT JOIN sys.columns c ON c.object_id = ck.parent_object_id AND c.column_id = ck.parent_column_id
 ORDER BY s.[name], o.[name], ck.[name];
+
+-- 8. Extended properties, every name, on the database, schemas, tables, columns, constraints and indexes.
+--    MS_Description comes along too; map.ts keeps it apart where it is already the description.
+SELECT CAST('database' AS varchar(10)) AS [on], CAST(NULL AS sysname) AS [schema], CAST(NULL AS sysname) AS [table],
+       CAST(NULL AS sysname) AS [item], ep.[name] AS [name], CAST(ep.[value] AS nvarchar(max)) AS [value]
+FROM sys.extended_properties ep
+WHERE ep.class = 0
+UNION ALL
+SELECT 'schema', s.[name], NULL, NULL, ep.[name], CAST(ep.[value] AS nvarchar(max))
+FROM sys.extended_properties ep
+JOIN sys.schemas s ON s.schema_id = ep.major_id
+WHERE ep.class = 3
+UNION ALL
+SELECT CASE WHEN ep.minor_id = 0 THEN 'table' ELSE 'column' END, s.[name], o.[name], c.[name], ep.[name], CAST(ep.[value] AS nvarchar(max))
+FROM sys.extended_properties ep
+JOIN sys.objects o ON o.object_id = ep.major_id AND o.[type] IN ('U', 'V') AND o.is_ms_shipped = 0
+JOIN sys.schemas s ON s.schema_id = o.schema_id
+LEFT JOIN sys.columns c ON c.object_id = ep.major_id AND c.column_id = ep.minor_id
+WHERE ep.class = 1
+UNION ALL
+SELECT 'constraint', s.[name], t.[name], k.[name], ep.[name], CAST(ep.[value] AS nvarchar(max))
+FROM sys.extended_properties ep
+JOIN sys.objects k ON k.object_id = ep.major_id AND k.[type] IN ('PK', 'UQ', 'F', 'C')
+JOIN sys.objects t ON t.object_id = k.parent_object_id AND t.is_ms_shipped = 0
+JOIN sys.schemas s ON s.schema_id = t.schema_id
+WHERE ep.class = 1 AND ep.minor_id = 0
+UNION ALL
+SELECT 'index', s.[name], o.[name], i.[name], ep.[name], CAST(ep.[value] AS nvarchar(max))
+FROM sys.extended_properties ep
+JOIN sys.indexes i ON i.object_id = ep.major_id AND i.index_id = ep.minor_id
+JOIN sys.objects o ON o.object_id = i.object_id AND o.is_ms_shipped = 0
+JOIN sys.schemas s ON s.schema_id = o.schema_id
+WHERE ep.class = 7;
+
+-- 9. What else the catalogue says about each table: temporal, memory-optimised, ledger, partitioned,
+--    compressed, change tracking, change data capture. Assembled as text: a column the server is too old
+--    to have is read as NULL. The literal starts as nvarchar(max) so the text is never cut at 4,000.
+DECLARE @temporal bit = CASE WHEN COL_LENGTH('sys.tables', 'temporal_type') IS NOT NULL THEN 1 ELSE 0 END;
+DECLARE @features nvarchar(max) = CAST(N'' AS nvarchar(max)) + N'
+SELECT s.[name] AS [schema],
+       t.[name] AS [table],
+       ' + CASE WHEN @temporal = 1 THEN N't.temporal_type' ELSE N'CAST(NULL AS tinyint)' END + N' AS [temporalType],
+       ' + CASE WHEN @temporal = 1 THEN N'OBJECT_SCHEMA_NAME(t.history_table_id)' ELSE N'CAST(NULL AS sysname)' END + N' AS [historySchema],
+       ' + CASE WHEN @temporal = 1 THEN N'OBJECT_NAME(t.history_table_id)' ELSE N'CAST(NULL AS sysname)' END + N' AS [historyTable],
+       ' + CASE WHEN @temporal = 1
+                THEN N'(SELECT c.[name] FROM sys.periods p JOIN sys.columns c ON c.object_id = p.object_id AND c.column_id = p.start_column_id WHERE p.object_id = t.object_id)'
+                ELSE N'CAST(NULL AS sysname)' END + N' AS [periodStart],
+       ' + CASE WHEN @temporal = 1
+                THEN N'(SELECT c.[name] FROM sys.periods p JOIN sys.columns c ON c.object_id = p.object_id AND c.column_id = p.end_column_id WHERE p.object_id = t.object_id)'
+                ELSE N'CAST(NULL AS sysname)' END + N' AS [periodEnd],
+       ' + CASE WHEN COL_LENGTH('sys.tables', 'is_memory_optimized') IS NOT NULL THEN N't.is_memory_optimized' ELSE N'CAST(0 AS bit)' END + N' AS [memoryOptimised],
+       ' + CASE WHEN COL_LENGTH('sys.tables', 'durability_desc') IS NOT NULL THEN N't.durability_desc' ELSE N'CAST(NULL AS nvarchar(60))' END + N' AS [durability],
+       ' + CASE WHEN COL_LENGTH('sys.tables', 'ledger_type_desc') IS NOT NULL THEN N't.ledger_type_desc' ELSE N'CAST(NULL AS nvarchar(60))' END + N' AS [ledger],
+       t.is_tracked_by_cdc AS [cdc],
+       CASE WHEN ct.object_id IS NULL THEN 0 ELSE 1 END AS [changeTracking],
+       ps.[name] AS [scheme],
+       pf.[name] AS [function],
+       pc.[name] AS [partitionColumn],
+       (SELECT COUNT(*) FROM sys.partitions p WHERE p.object_id = t.object_id AND p.index_id IN (0, 1)) AS [partitions],
+       -- The compression of every partition, comma-separated, since partitions may differ.
+       STUFF((SELECT DISTINCT N'','' + p.data_compression_desc FROM sys.partitions p WHERE p.object_id = t.object_id AND p.index_id IN (0, 1) FOR XML PATH(N'''')), 1, 1, N'''') AS [compression]
+FROM sys.tables t
+JOIN sys.schemas s ON s.schema_id = t.schema_id
+LEFT JOIN sys.indexes i ON i.object_id = t.object_id AND i.index_id IN (0, 1)
+LEFT JOIN sys.partition_schemes ps ON ps.data_space_id = i.data_space_id
+LEFT JOIN sys.partition_functions pf ON pf.function_id = ps.function_id
+LEFT JOIN sys.index_columns ic ON ic.object_id = i.object_id AND ic.index_id = i.index_id AND ic.partition_ordinal = 1
+LEFT JOIN sys.columns pc ON pc.object_id = ic.object_id AND pc.column_id = ic.column_id
+LEFT JOIN sys.change_tracking_tables ct ON ct.object_id = t.object_id
+WHERE t.is_ms_shipped = 0
+ORDER BY s.[name], t.[name];';
+EXEC sys.sp_executesql @features;
+
+-- 10. Triggers on tables and views, one row per trigger and event. A trigger created WITH ENCRYPTION has no
+--     definition to read.
+SELECT s.[name] AS [schema],
+       o.[name] AS [table],
+       tr.[name] AS [name],
+       tr.is_instead_of_trigger AS [insteadOf],
+       tr.is_disabled AS [disabled],
+       te.type_desc AS [event],
+       m.[definition] AS [definition]
+FROM sys.triggers tr
+JOIN sys.objects o ON o.object_id = tr.parent_id AND o.[type] IN ('U', 'V') AND o.is_ms_shipped = 0
+JOIN sys.schemas s ON s.schema_id = o.schema_id
+JOIN sys.trigger_events te ON te.object_id = tr.object_id
+LEFT JOIN sys.sql_modules m ON m.object_id = tr.object_id
+WHERE tr.parent_class = 1
+ORDER BY s.[name], o.[name], tr.[name], te.[type];
+
+-- 11. Row-level security predicates on each table (SQL Server 2016 on).
+IF OBJECT_ID('sys.security_predicates') IS NOT NULL
+    EXEC sys.sp_executesql N'
+    SELECT s.[name] AS [schema],
+           o.[name] AS [table],
+           ps.[name] AS [policySchema],
+           p.[name] AS [policy],
+           p.is_enabled AS [enabled],
+           sp.predicate_type_desc AS [kind],
+           sp.operation_desc AS [operation],
+           sp.predicate_definition AS [predicate]
+    FROM sys.security_predicates sp
+    JOIN sys.security_policies p ON p.object_id = sp.object_id
+    JOIN sys.schemas ps ON ps.schema_id = p.schema_id
+    JOIN sys.objects o ON o.object_id = sp.target_object_id
+    JOIN sys.schemas s ON s.schema_id = o.schema_id
+    ORDER BY s.[name], o.[name], p.[name], sp.security_predicate_id;';
+ELSE
+    SELECT TOP (0) CAST(NULL AS sysname) AS [schema];
+
+-- 12. Masked and Always Encrypted columns (SQL Server 2016 on).
+IF COL_LENGTH('sys.columns', 'encryption_type') IS NOT NULL AND OBJECT_ID('sys.masked_columns') IS NOT NULL
+    EXEC sys.sp_executesql N'
+    SELECT s.[name] AS [schema],
+           o.[name] AS [table],
+           c.[name] AS [column],
+           mc.masking_function AS [masked],
+           c.encryption_type_desc AS [encryption],
+           k.[name] AS [key]
+    FROM sys.columns c
+    JOIN sys.objects o ON o.object_id = c.object_id AND o.[type] IN (''U'', ''V'') AND o.is_ms_shipped = 0
+    JOIN sys.schemas s ON s.schema_id = o.schema_id
+    LEFT JOIN sys.masked_columns mc ON mc.object_id = c.object_id AND mc.column_id = c.column_id AND mc.is_masked = 1
+    LEFT JOIN sys.column_encryption_keys k ON k.column_encryption_key_id = c.column_encryption_key_id
+    WHERE mc.object_id IS NOT NULL OR c.encryption_type IS NOT NULL;';
+ELSE
+    SELECT TOP (0) CAST(NULL AS sysname) AS [schema];
+
+-- 13. Sensitivity labels on columns (SQL Server 2019 on, and Azure SQL, which fills them in from data
+--     discovery), only when the login may read them. The nested IF keeps the permission's name, unknown to
+--     an older server, from being asked about there.
+DECLARE @labelsRead bit = 0;
+IF OBJECT_ID('sys.sensitivity_classifications') IS NOT NULL
+    IF HAS_PERMS_BY_NAME(DB_NAME(), 'DATABASE', 'VIEW ANY SENSITIVITY CLASSIFICATION') = 1 SET @labelsRead = 1;
+IF @labelsRead = 1
+BEGIN
+    DECLARE @labels nvarchar(max) = CAST(N'' AS nvarchar(max)) + N'
+    SELECT s.[name] AS [schema],
+           o.[name] AS [table],
+           c.[name] AS [column],
+           CAST(sc.label AS nvarchar(256)) AS [label],
+           CAST(sc.information_type AS nvarchar(256)) AS [informationType],
+           ' + CASE WHEN COL_LENGTH('sys.sensitivity_classifications', 'rank_desc') IS NOT NULL THEN N'sc.rank_desc' ELSE N'CAST(NULL AS nvarchar(60))' END + N' AS [rank]
+    FROM sys.sensitivity_classifications sc
+    JOIN sys.objects o ON o.object_id = sc.major_id AND o.is_ms_shipped = 0
+    JOIN sys.schemas s ON s.schema_id = o.schema_id
+    JOIN sys.columns c ON c.object_id = sc.major_id AND c.column_id = sc.minor_id
+    WHERE sc.class = 1;';
+    EXEC sys.sp_executesql @labels;
+END
+ELSE
+    SELECT TOP (0) CAST(NULL AS sysname) AS [schema];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dbtour-source-mssql",
-  "version": "0.2.4",
+  "version": "0.4.0",
   "description": "SQL Server source for dbtour: tables, views, columns, keys, relations, indexes, descriptions.",
   "type": "module",
   "license": "MIT",
@@ -36,6 +36,6 @@
   },
   "devDependencies": {
     "@types/mssql": "^9.1.8",
-    "dbtour": "0.2.4"
+    "dbtour": "0.4.0"
   }
 }