Reverted some F# docs by Copilot, because FSharp.Formatting started to crash due to them.

Author: Thorium

docs/content/core/sqlite.fsx

@@ -1,4 +1,4 @@
-(*** hide ***)
+(*** hide ***)
 #I @"../../../bin/lib/netstandard2.0"
 #r "FSharp.Data.SqlProvider.Common.dll"
 #r "FSharp.Data.SqlProvider.dll"
@@ -95,8 +95,10 @@ let customers =
 
 When you do insert operation, after .SubmitUpdates call you can get inserted rowid like this:
 
-*)
-
+```fsharp
 let myCustomer = ctx.Main.Customers.``Create(CompanyName)``("MyCompany")
 ctx.SubmitUpdates()
 let rowid = myCustomer.GetColumn("rowid") : int
+```
+
+*)

src/SQLProvider.Common/Operators.fs

@@ -100,10 +100,8 @@ type SelectOperations =
 module ColumnSchema =
 
     type alias = string
-    /// <summary>
     /// Represents WHERE clause conditions for SQL queries.
     /// Supports complex boolean expressions with AND/OR operators and nested conditions.
-    /// </summary>
     type Condition =
         // this is  (table alias * column name * operator * right hand value ) list  * (the same again list)
         // basically any AND or OR expression can have N terms and can have N nested condition children
@@ -121,10 +119,8 @@ module ColumnSchema =
         /// Expression that cannot be translated to SQL
         | NotSupported of System.Linq.Expressions.Expression
 
-    /// <summary>
     /// Represents SQL functions and operations that can be applied to columns.
     /// These operations are translated to database-specific SQL functions.
-    /// </summary>
     and CanonicalOp =
     //String functions
     /// Extracts a substring from the specified position to the end
@@ -230,9 +226,7 @@ module ColumnSchema =
     /// Casts a value to INTEGER type
     | CastInt
 
-    /// <summary>
     /// Represents a column with optional operations applied to it.
-    /// </summary>
     and SqlColumnType =
     /// A key column used for grouping or joining
     | KeyColumn of string
@@ -241,9 +235,7 @@ module ColumnSchema =
     /// A column used in aggregate operations
     | GroupColumn of AggregateOperation * SqlColumnType
 
-    /// <summary>
     /// Represents either a database column or a constant value in SQL expressions.
-    /// </summary>
     // More recursion, because you mighn want to say e.g.
     // where (x.Substring(x.IndexOf("."), (x.Length-x.IndexOf("."))
     and SqlItemOrColumn =
@@ -252,9 +244,7 @@ module ColumnSchema =
     /// A constant value to be used in SQL expressions
     | SqlConstant of obj
 
-    /// <summary>
     /// Represents parameters for SQL projections (SELECT clause elements).
-    /// </summary>
     type ProjectionParameter =
     /// A direct entity column reference
     | EntityColumn of string
@@ -263,72 +253,52 @@ module ColumnSchema =
 
 // Dummy operators, these are placeholders that are replaced in the expression tree traversal with special server-side operations such as In, Like
 // The operators here are used to force the compiler to statically check against the correct types
-/// <summary>
+
 /// Contains custom SQL operators for use in query expressions.
 /// These operators are translated to their SQL equivalents during query compilation.
-/// </summary>
 [<AutoOpenAttribute>]
 module Operators =
-    /// <summary>
     /// SQL IN operator. Tests if a value exists in a sequence.
-    /// Example: where (customer.Country |=| ["USA"; "Canada"])
-    /// </summary>
-    /// <param name="a">The value to test</param>
-    /// <param name="b">The sequence to search in</param>
-    /// <returns>Always false at compile time - replaced with SQL IN during query execution</returns>
+    /// param a: The value to test
+    /// param b: The sequence to search in
+    /// returns: Always false at compile time - replaced with SQL IN during query execution
     let (|=|) (a:'a) (b:'a seq) = false
 
-    /// <summary>
     /// SQL NOT IN operator. Tests if a value does not exist in a sequence.
-    /// Example: where (customer.Country |<>| ["USA"; "Canada"])
-    /// </summary>
-    /// <param name="a">The value to test</param>
-    /// <param name="b">The sequence to search in</param>
-    /// <returns>Always false at compile time - replaced with SQL NOT IN during query execution</returns>
+    /// param a: The value to test
+    /// param b: The sequence to search in
+    /// returns: Always false at compile time - replaced with SQL NOT IN during query execution
     let (|<>|) (a:'a) (b:'a seq) = false
 
-    /// <summary>
     /// SQL LIKE operator for pattern matching with wildcards.
-    /// Example: where (customer.Name =% "John%")
-    /// </summary>
-    /// <param name="a">The value to test</param>
-    /// <param name="b">The pattern to match (use % and _ as wildcards)</param>
-    /// <returns>Always false at compile time - replaced with SQL LIKE during query execution</returns>
+    /// param a: The value to test
+    /// param b: The pattern to match
+    /// returns: Always false at compile time - replaced with SQL LIKE during query execution
     let (=%) (a:'a) (b:string) = false
 
-    /// <summary>
     /// SQL NOT LIKE operator for negated pattern matching.
-    /// Example: where (customer.Name <>% "John%")
-    /// </summary>
-    /// <param name="a">The value to test</param>
-    /// <param name="b">The pattern to reject</param>
-    /// <returns>Always false at compile time - replaced with SQL NOT LIKE during query execution</returns>
+    /// param a: The value to test
+    /// param b: The pattern to reject
+    /// returns>Always false at compile time - replaced with SQL NOT LIKE during query execution
     let (<>%) (a:'a) (b:string) = false
 
     /// Left join helper function for internal use
     let private leftJoin (a:'a) = a
 
-    /// <summary>
     /// Left outer join operator. Performs a left join on a related table.
-    /// Example: for customer in ctx.Main.Customers do
-    ///          for order in (!!) customer.``main.Orders by CustomerID`` do
-    /// </summary>
-    /// <param name="a">The related table queryable</param>
-    /// <returns>A queryable that performs a left outer join</returns>
+    /// Used after "in" and before the context.tablename
+    /// param a: The related table queryable
+    /// A queryable that performs a left outer join
     let (!!) (a:IQueryable<'a>) = query { for x in a do select (leftJoin x) } 
 
-    /// <summary>
     /// Calculates the standard deviation of numeric values in a column.
     /// Used in aggregate queries with groupBy.
-    /// </summary>
-    /// <param name="a">The column value</param>
-    /// <returns>Always 1m at compile time - replaced with SQL STDDEV during query execution</returns>
+    /// param a: The column value
+    /// returns: Always 1m at compile time - replaced with SQL STDDEV during query execution
     let StdDev (a:'a) = 1m
 
-    /// <summary>
     /// Calculates the variance of numeric values in a column.
     /// Used in aggregate queries with groupBy.
-    /// </summary>
-    /// <param name="a">The column value</param>
-    /// <returns>Always 1m at compile time - replaced with SQL VARIANCE during query execution</returns>
+    /// param a: The column value
+    /// returns: Always 1m at compile time - replaced with SQL VARIANCE during query execution
     let Variance (a:'a) = 1m

src/SQLProvider.Common/SqlRuntime.Async.fs

@@ -8,18 +8,14 @@ open FSharp.Data.Sql.Common
 open FSharp.Data.Sql.Patterns
 open System.Linq
 
-/// <summary>
 /// Provides asynchronous operations for SQL queries.
 /// Use these functions when you need to execute queries asynchronously to avoid blocking threads.
-/// </summary>
 module AsyncOperations =
 
-    /// <summary>
     /// Executes a queryable asynchronously and returns the results as a sequence.
     /// This is useful for executing large queries without blocking the calling thread.
-    /// </summary>
-    /// <param name="s">The queryable to execute</param>
-    /// <returns>A task that yields a sequence of results</returns>
+    /// param s: The queryable to execute
+    /// returns: A task that yields a sequence of results
     let executeAsync (s:Linq.IQueryable<'T>) =
         let inline yieldseq (en: IEnumerator<'T>) =
             seq {

src/SQLProvider.Common/SqlRuntime.Common.fs

@@ -16,10 +16,8 @@ open Microsoft.FSharp.Reflection
 open System.Collections.Concurrent
 open System.Runtime.Serialization
 
-/// <summary>
 /// Specifies the database provider type for the SQL type provider.
 /// Each provider has its own specific implementation for SQL generation and data type mapping.
-/// </summary>
 type DatabaseProviderTypes =
     /// Microsoft SQL Server using SqlClient provider
     | MSSQLSERVER = 0
@@ -46,16 +44,14 @@ type DatabaseProviderTypes =
     /// External/custom database provider
     | EXTERNAL = 11
 
-/// <summary>Specifies the direction for relationship navigation.</summary>
+/// Specifies the direction for relationship navigation.
 type RelationshipDirection = 
     /// Navigate to child records (foreign key relationships)
     Children = 0
     /// Navigate to parent records (primary key relationships)
     | Parents = 1
 
-/// <summary>
 /// Specifies how to handle case sensitivity when generating table and column names.
-/// </summary>
 type CaseSensitivityChange =
     /// Keep original casing from the database
     | ORIGINAL = 0
@@ -64,9 +60,7 @@ type CaseSensitivityChange =
     /// Convert all names to lowercase
     | TOLOWER = 2
 
-/// <summary>
 /// Specifies how to represent nullable database columns in the generated types.
-/// </summary>
 type NullableColumnType =
     /// Nullable types are just Unchecked default. (Old false.)
     | NO_OPTION = 0
@@ -75,9 +69,7 @@ type NullableColumnType =
     /// ValueOption is more performant.
     | VALUE_OPTION = 2
 
-/// <summary>
 /// Specifies the quote character style for ODBC connections when dealing with table and column names containing spaces or special characters.
-/// </summary>
 type OdbcQuoteCharacter =
     /// Use default quoting for the ODBC driver
     | DEFAULT_QUOTE = 0
@@ -87,15 +79,13 @@ type OdbcQuoteCharacter =
     | SQUARE_BRACKETS = 2
     /// Plain, no special names: alias
     | NO_QUOTES = 3 // alias
-    /// Amazon Redshift style: "alias" & Firebird style too
+    /// Amazon Redshift style: "alias" and Firebird style too
     | DOUBLE_QUOTES = 4
     /// Single quote: 'alias'
     | APHOSTROPHE = 5 
 
-/// <summary>
 /// Specifies which SQLite library to use for connections.
 /// Different libraries may have different capabilities and platform support.
-/// </summary>
 type SQLiteLibrary =
     /// .NET Framework default
     | SystemDataSQLite = 0
@@ -106,16 +96,12 @@ type SQLiteLibrary =
     /// Microsoft.Data.Sqlite. May support .NET Standard 2.0 contract in the future.
     | MicrosoftDataSqlite = 3
 
-/// <summary>
 /// Contains events for monitoring SQL query execution and debugging.
 /// Use these events to log, debug, or analyze the SQL queries generated by the type provider.
-/// </summary>
 module public QueryEvents =
 
-   /// <summary>
    /// Contains information about a SQL command being executed, including the command text,
    /// parameters, and connection information for debugging and monitoring purposes.
-   /// </summary>
    type SqlEventData = {
        /// The text of the SQL command being executed.
        Command: string
@@ -158,18 +144,9 @@ module public QueryEvents =
 
    let private sqlEvent = Event<SqlEventData>()
 
-   /// <summary>
    /// Event that fires immediately before the execution of every generated query. 
    /// Listen to this event to display or debug the content of your queries.
    /// This is useful for logging, performance monitoring, and debugging SQL generation.
-   /// </summary>
-   /// <example>
-   /// <code>
-   /// QueryEvents.SqlQueryEvent.Add(fun event ->
-   ///     printfn "Executing: %s" event.Command
-   ///     printfn "Parameters: %A" event.Parameters)
-   /// </code>
-   /// </example>
    [<CLIEvent>]
    let SqlQueryEvent = sqlEvent.Publish
 
@@ -206,10 +183,8 @@ module public QueryEvents =
    let internal PublishExpression(e) = expressionEvent.Trigger(e)
 
 [<Struct>]
-/// <summary>
 /// Represents the current state of a database entity for change tracking purposes.
 /// Used internally by the SQL provider to determine what operations need to be performed during SubmitUpdates().
-/// </summary>
 type EntityState =
     /// Entity has not been modified since it was loaded
     | Unchanged
@@ -222,10 +197,8 @@ type EntityState =
     /// Entity has been deleted from the database
     | Deleted
 
-/// <summary>
 /// Specifies how to handle conflicts when inserting records with duplicate primary keys.
 /// Currently supported only on databases that have UPSERT capabilities.
-/// </summary>
 [<Struct>]
 type OnConflict = 
     /// Throws an exception if the primary key already exists (default behaviour).
@@ -237,16 +210,8 @@ type OnConflict =
     /// Currently supported only on PostgreSQL 9.5+
     | DoNothing
 
-/// <summary>
 /// Attribute for mapping entity properties to database columns with different names.
 /// Use this when your database column name differs from your preferred F# property name.
-/// </summary>
-/// <example>
-/// <code>
-/// [&lt;MappedColumn("customer_id")&gt;]
-/// member x.CustomerId = x.GetColumn&lt;int&gt;("customer_id")
-/// </code>
-/// </example>
 type MappedColumnAttribute(name: string) = 
     inherit Attribute()
     /// Gets the database column name this property maps to
@@ -569,11 +534,9 @@ type SqlEntity(dc: ISqlDataContext, tableName, columns: ColumnLookup, activeColu
                                  override __.ShouldSerializeValue(_) = false })
                |> Seq.cast<PropertyDescriptor> |> Seq.toArray )
 
-/// <summary>
 /// The main interface for SQL data context operations. This interface provides all the core functionality
 /// for querying, creating, updating, and deleting data through the SQL type provider.
 /// Users typically access this through the generated GetDataContext() method.
-/// </summary>
 and ISqlDataContext =
     /// Connection string to database
     abstract ConnectionString           : string
@@ -616,10 +579,8 @@ and ISqlDataContext =
     /// Context meant to be read operations only
     abstract IsReadOnly                 : bool
 
-/// <summary>
 /// Interface implemented by generated types that provide access to the underlying data context.
 /// This allows access to the ISqlDataContext for advanced operations.
-/// </summary>
 type IWithDataContext =
     /// Gets the underlying SQL data context
     abstract DataContext : ISqlDataContext

src/SQLProvider.Common/SqlRuntime.Transactions.fs

@@ -2,10 +2,8 @@ namespace FSharp.Data.Sql.Transactions
 
 open System
 
-/// <summary>
 /// Transaction isolation level for database operations.
 /// Corresponds to the System.Transactions.IsolationLevel but provides SQL provider specific functionality.
-/// </summary>
 type IsolationLevel =
     /// Highest isolation level - transactions are completely isolated from each other
     | Serializable = 0
@@ -24,10 +22,8 @@ type IsolationLevel =
     /// Special value to indicate that no transaction should be created
     | DontCreateTransaction = 99
 
-/// <summary>
 /// Configuration options for database transactions.
 /// Corresponds to the System.Transactions.TransactionOptions.
-/// </summary>
 [<Struct>]
 type TransactionOptions = {
     /// Maximum time the transaction can remain active before timing out
@@ -36,9 +32,7 @@ type TransactionOptions = {
     IsolationLevel : IsolationLevel
 }
 
-/// <summary>
 /// Utility functions for converting between different transaction isolation level representations.
-/// </summary>
 module TransactionUtils =
     let internal toSystemTransactionsIsolationLevel isolationLevel =
         match isolationLevel with
@@ -51,12 +45,10 @@ module TransactionUtils =
         | IsolationLevel.Unspecified -> System.Transactions.IsolationLevel.Unspecified
         | _ -> failwithf "Unhandled IsolationLevel value: %A." isolationLevel
 
-    /// <summary>
     /// Converts SQL provider isolation level to System.Data.IsolationLevel.
     /// Use this when you need to work directly with ADO.NET connection transactions.
-    /// </summary>
-    /// <param name="isolationLevel">The SQL provider isolation level</param>
-    /// <returns>The corresponding System.Data.IsolationLevel</returns>
+    /// param isolationLevel: The SQL provider isolation level
+    /// returns: The corresponding System.Data.IsolationLevel
     let toSystemDataIsolationLevel isolationLevel =
         match isolationLevel with
         | IsolationLevel.Serializable -> System.Data.IsolationLevel.Serializable