Populate sys.indexes.filter_definition (byte-exact canonical) and sys.check_constraints.definition / sys.default_constraints.definition (original source syntax via ParserContext.SourceTextFrom).

Author: RyanLamansky

SqlServerSimulator.Tests/CheckConstraintTests.cs

@@ -296,4 +296,28 @@ insert t values (null, null, null)
             """));
         Assert.AreEqual("547", ex.Data["HelpLink.EvtID"]);
     }
+
+    // sys.check_constraints.definition holds the predicate's original syntax,
+    // wrapped in one paren pair (the simulator doesn't re-normalize to SQL
+    // Server's canonical [col]=(1)-style form). Covers inline column-level,
+    // table-level, and the broad grammar (OR / IN / functions) that the
+    // filtered-index renderer deliberately doesn't touch.
+    [TestMethod]
+    [DataRow("a int check (a > 0)", "(a > 0)")]
+    [DataRow("a int, b int, check (a > 0 and b < 10)", "(a > 0 and b < 10)")]
+    [DataRow("s varchar(2) check (s in ('A', 'B'))", "(s in ('A', 'B'))")]
+    [DataRow("n varchar(9) check (len(n) > 0 or n is null)", "(len(n) > 0 or n is null)")]
+    public void CheckConstraint_Definition_HoldsOriginalSyntax(string columns, string expected)
+        => Assert.AreEqual(expected, new Simulation().ExecuteScalar($"""
+            create table t (id int not null primary key, {columns});
+            select definition from sys.check_constraints
+            """));
+
+    [TestMethod]
+    public void CheckConstraint_AlterAddCheck_Definition_HoldsOriginalSyntax()
+        => Assert.AreEqual("(b >= a)", new Simulation().ExecuteScalar("""
+            create table t (id int not null primary key, a int, b int);
+            alter table t add constraint ck check (b >= a);
+            select definition from sys.check_constraints where name = 'ck'
+            """));
 }

SqlServerSimulator.Tests/CreateIndexTests.cs

@@ -114,6 +114,46 @@ public void CreateIndex_WithFilter_HasFilterFlagSet()
             select has_filter from sys.indexes where name = 'ix_filter'
             """)!);
 
+    // sys.indexes.filter_definition normalization — every expected string is
+    // verbatim from SQL Server 2025: columns bracketed, numerics parenthesized
+    // (literal scale preserved), strings quoted (N-prefixed for nvarchar
+    // literals), operators space-free, AND / IS [NOT] NULL / IN uppercase-spaced.
+    [TestMethod]
+    [DataRow("status = 1", "([status]=(1))")]
+    [DataRow("status <> 1", "([status]<>(1))")]
+    [DataRow("status >= 5 and status <= 10", "([status]>=(5) AND [status]<=(10))")]
+    [DataRow("code is not null", "([code] IS NOT NULL)")]
+    [DataRow("code is null", "([code] IS NULL)")]
+    [DataRow("status = 1 and code is not null", "([status]=(1) AND [code] IS NOT NULL)")]
+    [DataRow("name = 'abc'", "([name]='abc')")]
+    [DataRow("uname = N'abc'", "([uname]=N'abc')")]
+    [DataRow("x = -1", "([x]=(-1))")]
+    [DataRow("status in (1, 2, 3)", "([status] IN ((1), (2), (3)))")]
+    [DataRow("nm = 0.10", "([nm]=(0.10))")]
+    public void CreateIndex_FilterDefinition_NormalizedLikeSqlServer(string filter, string expected)
+        => AreEqual(expected, new Simulation().ExecuteScalar($"""
+            create table t (id int not null primary key, status int, code int,
+                            name varchar(50), uname nvarchar(50), x int, nm decimal(10, 2));
+            create unique index ix on t(id) where {filter};
+            select filter_definition from sys.indexes where name = 'ix'
+            """));
+
+    // A predicate outside the renderable filtered grammar (OR — which a real
+    // server rejects at CREATE, but the simulator's looser parser accepts):
+    // has_filter stays set, filter_definition degrades to NULL rather than
+    // emitting a non-canonical rendering.
+    [TestMethod]
+    public void CreateIndex_FilterDefinition_UnrenderablePredicate_IsNull()
+    {
+        var sim = new Simulation();
+        _ = sim.ExecuteNonQuery("""
+            create table t (id int not null primary key, status int);
+            create unique index ix on t(id) where status = 1 or status = 2
+            """);
+        IsTrue((bool)sim.ExecuteScalar("select has_filter from sys.indexes where name = 'ix'")!);
+        AreEqual(0, sim.ExecuteScalar("select count(filter_definition) from sys.indexes where name = 'ix'"));
+    }
+
     [TestMethod]
     public void CreateIndex_WithOptionsClause_Accepted()
         => AreEqual(1, new Simulation().ExecuteScalar("""

SqlServerSimulator.Tests/DefaultClauseTests.cs

@@ -169,4 +169,26 @@ insert t (id) values (1)
         Assert.IsTrue(reader.Read());
         Assert.AreNotEqual(Guid.Empty, reader.GetGuid(0));
     }
+
+    // sys.default_constraints.definition holds the default expression's original
+    // syntax, wrapped in one paren pair (the simulator doesn't re-normalize to
+    // SQL Server's canonical parenthesization — getdate() happens to coincide).
+    [TestMethod]
+    [DataRow("qty int default 0", "(0)")]
+    [DataRow("created datetime default getdate()", "(getdate())")]
+    [DataRow("code int default (1 + 2)", "((1 + 2))")]
+    [DataRow("nm varchar(5) default 'x'", "('x')")]
+    public void DefaultConstraint_Definition_HoldsOriginalSyntax(string column, string expected)
+        => Assert.AreEqual(expected, new Simulation().ExecuteScalar($"""
+            create table t (id int not null primary key, {column});
+            select definition from sys.default_constraints
+            """));
+
+    [TestMethod]
+    public void DefaultConstraint_AlterAddDefault_Definition_HoldsOriginalSyntax()
+        => Assert.AreEqual("(-1)", new Simulation().ExecuteScalar("""
+            create table t (id int not null primary key, b int);
+            alter table t add constraint df default (-1) for b;
+            select definition from sys.default_constraints where name = 'df'
+            """));
 }

SqlServerSimulator/Parser/BooleanExpression.cs

@@ -1,5 +1,8 @@
 using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
+using System.Globalization;
+using System.Text;
+using SqlServerSimulator.Parser.Expressions;
 using SqlServerSimulator.Parser.Tokens;
 using SqlServerSimulator.Storage;
 
@@ -29,6 +32,98 @@ private protected BooleanExpression()
     {
     }
 
+    /// <summary>
+    /// Renders this predicate into the normalized form SQL Server stores in
+    /// <c>sys.indexes.filter_definition</c> for a filtered index — columns
+    /// bracketed, numeric constants parenthesized, strings quoted, operators
+    /// space-free (<c>[status]=(1)</c>), and <c>AND</c> / <c>IS [NOT] NULL</c> /
+    /// <c>IN</c> uppercase-spaced — or returns <c>null</c> when the predicate
+    /// falls outside the renderable filtered-predicate grammar (an <c>AND</c> of
+    /// comparison / <c>IS [NOT] NULL</c> / <c>IN</c> over <c>column &lt;op&gt;
+    /// constant</c>). Those excluded shapes — <c>OR</c>, <c>NOT</c>, <c>BETWEEN</c>,
+    /// function calls — are exactly the ones real SQL Server rejects in a filtered
+    /// index, so reporting <c>null</c> for them never hides a definition a real
+    /// server would have stored. The whole predicate is wrapped in one outer pair
+    /// of parens.
+    /// </summary>
+    internal string? RenderFilterDefinition(BatchContext batch)
+    {
+        var sb = new StringBuilder("(");
+        if (!this.TryAppendFilterDefinition(sb, batch))
+            return null;
+        _ = sb.Append(')');
+        return sb.ToString();
+    }
+
+    // Appends this predicate's canonical fragment to `sb`, or returns false when
+    // the node isn't part of the renderable filtered-predicate grammar. Default:
+    // not renderable (OR / NOT / DISTINCT FROM / EXISTS / BETWEEN / quantified).
+    private protected virtual bool TryAppendFilterDefinition(StringBuilder sb, BatchContext batch) => false;
+
+    // Renders one comparison / IN operand: a single-part column reference as
+    // [name], or an otherwise constant-foldable side as its literal. Returns
+    // false for anything that isn't a bare column or a constant.
+    private static bool TryAppendFilterOperand(StringBuilder sb, Expression operand, BatchContext batch)
+    {
+        while (operand is Parenthesized paren)
+            operand = paren.Wrapped;
+
+        if (operand is Reference reference && reference.ReferencedName.Count == 1)
+        {
+            _ = sb.Append('[').Append(reference.ReferencedName.Leaf).Append(']');
+            return true;
+        }
+
+        SqlValue value;
+        try
+        {
+            value = operand.Run(new RuntimeContext(static _ => throw new NotSupportedException(), batch));
+        }
+        catch (Exception ex) when (ex is SimulatedSqlException or NotSupportedException)
+        {
+            return false;
+        }
+
+        if (FormatFilterLiteral(value) is not { } literal)
+            return false;
+        _ = sb.Append(literal);
+        return true;
+    }
+
+    // Formats a constant as SQL Server renders it inside filter_definition:
+    // strings quoted (N-prefixed when the literal is national / Unicode), numerics
+    // parenthesized in invariant culture preserving the literal's scale. Returns
+    // null for a NULL literal or a type with no canonical filter rendering
+    // (dates / binary / guid — rare in a filtered predicate), bailing the whole
+    // render to a null definition.
+    private static string? FormatFilterLiteral(SqlValue value)
+    {
+        if (value.IsNull)
+            return null;
+
+        var type = value.Type;
+        if (type.Category == SqlTypeCategory.String)
+        {
+            var prefix = type is NVarcharSqlType or NCharSqlType ? "N" : string.Empty;
+            return $"{prefix}'{value.AsString.Replace("'", "''", StringComparison.Ordinal)}'";
+        }
+
+        var text = type switch
+        {
+            _ when type == SqlType.Int32 => value.AsInt32.ToString(CultureInfo.InvariantCulture),
+            _ when type == SqlType.BigInt => value.AsInt64.ToString(CultureInfo.InvariantCulture),
+            _ when type == SqlType.SmallInt => value.AsInt16.ToString(CultureInfo.InvariantCulture),
+            _ when type == SqlType.TinyInt => value.AsByte.ToString(CultureInfo.InvariantCulture),
+            _ when type == SqlType.Bit => value.AsBoolean ? "1" : "0",
+            _ when type == SqlType.Money || type == SqlType.SmallMoney => value.AsMoney.ToString("F4", CultureInfo.InvariantCulture),
+            _ when type == SqlType.Float => value.AsDouble.ToString("G15", CultureInfo.InvariantCulture),
+            _ when type == SqlType.Real => value.AsSingle.ToString("G7", CultureInfo.InvariantCulture),
+            DecimalSqlType d => value.AsDecimal.ToString($"F{d.scale}", CultureInfo.InvariantCulture),
+            _ => null,
+        };
+        return text is null ? null : $"({text})";
+    }
+
     /// <summary>
     /// Parses a full boolean predicate using SQL Server's standard
     /// precedence: <c>OR</c> binds loosest, then <c>AND</c>, then <c>NOT</c>,
@@ -601,6 +696,14 @@ internal override void CollectConjuncts(List<BooleanExpression> sink)
             left.CollectConjuncts(sink);
             right.CollectConjuncts(sink);
         }
+
+        private protected override bool TryAppendFilterDefinition(StringBuilder sb, BatchContext batch)
+        {
+            if (!left.TryAppendFilterDefinition(sb, batch))
+                return false;
+            _ = sb.Append(" AND ");
+            return right.TryAppendFilterDefinition(sb, batch);
+        }
     }
 
     /// <summary>
@@ -685,6 +788,14 @@ private sealed class IsNullExpression(Expression source, bool negated) : Boolean
         internal override string DebugDisplay() => $"{source.DebugDisplay()} IS {(negated ? "NOT NULL" : "NULL")}";
 
         internal override void VisitOperandExpressions(Action<Expression> visitor) => visitor(source);
+
+        private protected override bool TryAppendFilterDefinition(StringBuilder sb, BatchContext batch)
+        {
+            if (!TryAppendFilterOperand(sb, source, batch))
+                return false;
+            _ = sb.Append(negated ? " IS NOT NULL" : " IS NULL");
+            return true;
+        }
     }
 
     /// <summary>
@@ -766,6 +877,24 @@ internal override void VisitOperandExpressions(Action<Expression> visitor)
                 visitor(candidate);
         }
 
+        private protected override bool TryAppendFilterDefinition(StringBuilder sb, BatchContext batch)
+        {
+            // NOT IN isn't part of the filtered-index grammar (real SQL Server
+            // rejects it), so only the positive form renders.
+            if (negated || candidates.Length == 0 || !TryAppendFilterOperand(sb, source, batch))
+                return false;
+            _ = sb.Append(" IN (");
+            for (var i = 0; i < candidates.Length; i++)
+            {
+                if (i > 0)
+                    _ = sb.Append(", ");
+                if (!TryAppendFilterOperand(sb, candidates[i], batch))
+                    return false;
+            }
+            _ = sb.Append(')');
+            return true;
+        }
+
         // `source IN (c1, c2, ...)` is logically `source=c1 OR source=c2 OR ...`,
         // so for the equality-seek path it decomposes into one pair per candidate
         // against the shared LHS. NOT IN doesn't decompose into positive
@@ -1029,6 +1158,19 @@ internal override void VisitOperandExpressions(Action<Expression> visitor)
             visitor(this.left);
             visitor(this.right);
         }
+
+        // The space-free operator token this comparison renders into a filtered-
+        // index definition (=, <>, >, >=, <, <=), or null for shapes with no
+        // canonical filter rendering (LIKE) — those bail the whole render.
+        protected virtual string? FilterOperator => null;
+
+        private protected override bool TryAppendFilterDefinition(StringBuilder sb, BatchContext batch)
+        {
+            if (this.FilterOperator is not { } op || !TryAppendFilterOperand(sb, this.left, batch))
+                return false;
+            _ = sb.Append(op);
+            return TryAppendFilterOperand(sb, this.right, batch);
+        }
     }
 
     /// <summary>
@@ -1078,6 +1220,8 @@ private sealed class EqualityExpression(Expression left, Expression right) : Com
 
         internal override string DebugDisplay() => $"{left.DebugDisplay()} = {right.DebugDisplay()}";
 
+        protected override string? FilterOperator => "=";
+
         internal override bool TryGetEqualityOperands([NotNullWhen(true)] out Expression? l, [NotNullWhen(true)] out Expression? r)
         {
             l = left;
@@ -1092,6 +1236,8 @@ private sealed class InequalityExpression(Expression left, Expression right) : C
             ComparePromoted(left, right, runtime, "not equal to", static (l, r) => !l.Equals(r));
 
         internal override string DebugDisplay() => $"{left.DebugDisplay()} <> {right.DebugDisplay()}";
+
+        protected override string? FilterOperator => "<>";
     }
 
     private sealed class GreaterThanExpression(Expression left, Expression right) : CompareExpression(left, right)
@@ -1101,6 +1247,8 @@ private sealed class GreaterThanExpression(Expression left, Expression right) :
 
         internal override string DebugDisplay() => $"{left.DebugDisplay()} > {right.DebugDisplay()}";
 
+        protected override string? FilterOperator => ">";
+
         internal override bool TryGetRangeOperands([NotNullWhen(true)] out Expression? l, out RangeComparison op, [NotNullWhen(true)] out Expression? r)
         {
             (l, op, r) = (left, RangeComparison.Greater, right);
@@ -1115,6 +1263,8 @@ private sealed class GreaterThanOrEqualExpression(Expression left, Expression ri
 
         internal override string DebugDisplay() => $"{left.DebugDisplay()} >= {right.DebugDisplay()}";
 
+        protected override string? FilterOperator => ">=";
+
         internal override bool TryGetRangeOperands([NotNullWhen(true)] out Expression? l, out RangeComparison op, [NotNullWhen(true)] out Expression? r)
         {
             (l, op, r) = (left, RangeComparison.GreaterOrEqual, right);
@@ -1129,6 +1279,8 @@ private sealed class LessThanExpression(Expression left, Expression right) : Com
 
         internal override string DebugDisplay() => $"{left.DebugDisplay()} < {right.DebugDisplay()}";
 
+        protected override string? FilterOperator => "<";
+
         internal override bool TryGetRangeOperands([NotNullWhen(true)] out Expression? l, out RangeComparison op, [NotNullWhen(true)] out Expression? r)
         {
             (l, op, r) = (left, RangeComparison.Less, right);
@@ -1143,6 +1295,8 @@ private sealed class LessThanOrEqualExpression(Expression left, Expression right
 
         internal override string DebugDisplay() => $"{left.DebugDisplay()} <= {right.DebugDisplay()}";
 
+        protected override string? FilterOperator => "<=";
+
         internal override bool TryGetRangeOperands([NotNullWhen(true)] out Expression? l, out RangeComparison op, [NotNullWhen(true)] out Expression? r)
         {
             (l, op, r) = (left, RangeComparison.LessOrEqual, right);

SqlServerSimulator/Parser/ParserContext.cs

@@ -177,6 +177,18 @@ internal sealed class ParserContext(SimulatedDbCommand command, BatchContext bat
     /// </summary>
     public (int Index, Token? Token) SaveCheckpoint() => (this.index, this.Token);
 
+    /// <summary>
+    /// Raw source text of the command from <paramref name="startIndex"/> up to the
+    /// current (lookahead) <see cref="Token"/>, trailing whitespace trimmed —
+    /// capturing an expression's original syntax for catalog <c>definition</c>
+    /// columns (CHECK / DEFAULT). Pass the <see cref="Token.StartIndex"/> of the
+    /// expression's first token, snapshotted before parsing; call once the
+    /// expression parse has positioned <see cref="Token"/> on the following token
+    /// (or run off the end, where the slice extends to the command's end).
+    /// </summary>
+    public string SourceTextFrom(int startIndex) =>
+        this.commandText[startIndex..(this.Token?.StartIndex ?? this.commandText.Length)].TrimEnd();
+
     /// <summary>
     /// Restores a checkpoint captured by <see cref="SaveCheckpoint"/>.
     /// </summary>

SqlServerSimulator/Schemas/TableType.cs

@@ -50,7 +50,7 @@ internal sealed class TableType(
     DateTime createDate,
     HeapColumn[] columns,
     (KeyConstraintKind Kind, string? Name, int[] FullOrdinals)[] pendingKeys,
-    (string? Name, BooleanExpression Predicate, string? InlineColumn)[] pendingChecks)
+    (string? Name, BooleanExpression Predicate, string? InlineColumn, string Definition)[] pendingChecks)
     : SchemaObject(name, typeTableObjectId, schema.SchemaId, createDate)
 {
     public Schema Schema = schema;
@@ -86,7 +86,7 @@ internal sealed class TableType(
     /// Pending CHECK specs captured at CREATE TYPE time. Resolved per clone
     /// (same rationale as <see cref="PendingKeys"/>).
     /// </summary>
-    public readonly (string? Name, BooleanExpression Predicate, string? InlineColumn)[] PendingChecks = pendingChecks;
+    public readonly (string? Name, BooleanExpression Predicate, string? InlineColumn, string Definition)[] PendingChecks = pendingChecks;
 
     /// <summary>
     /// Materializes a fresh <see cref="HeapTable"/> for one <c>DECLARE @t

SqlServerSimulator/Simulation/Simulation.AlterTableColumn.cs

@@ -47,7 +47,7 @@ private static bool ParseAddColumns(ParserContext context, MultiPartName tableNa
         var heapColumns = new List<HeapColumn?>();
         var explicitNull = new List<bool>();
         var pendingKeys = new List<(KeyConstraintKind Kind, string? Name, int[] FullOrdinals)>();
-        var pendingChecks = new List<(string? Name, BooleanExpression Predicate, string? InlineColumn)>();
+        var pendingChecks = new List<(string? Name, BooleanExpression Predicate, string? InlineColumn, string Definition)>();
         var pendingComputed = new List<(int Index, string Name, Expression Expression, bool Persisted, bool Nullable)>();
         var pendingForeignKeys = new List<PendingForeignKey>();