SqlSugar ORM Documentation

Before running the benchmark suite, you must configure your database connection. Open BenchmarkConfig.cs and update the SqlServerConnection constant with your valid SQL Server connection string.

Requirements:

• .NET 6.0 or higher
• SQL Server (default)
• BenchmarkDotNet 0.13.12+

public const string SqlServerConnection = "server=.;uid=sa;pwd=YOUR_PASSWORD;database=SqlSugarBenchmark;Encrypt=True;TrustServerCertificate=True";

To execute the complete performance benchmark suite, use dotnet run with the Release configuration. To save time, you can run specific benchmark categories using the --filter flag.

Run all benchmarks:

dotnet run -c Release

Run specific benchmarks (e.g., QueryBenchmarks):

dotnet run -c Release -- --filter *QueryBenchmarks*

Before executing full benchmarks, run validation tests to ensure your database connection, entity creation, CRUD operations, bulk operations, join queries, and navigation properties are working correctly.

You can use the provided PowerShell script (recommended) or the dotnet CLI.

# Using PowerShell script (Recommended)
.\RunTests.ps1

# Or using dotnet CLI
dotnet run -c Release -- --test

If you encounter the error A network-related or instance-specific error occurred, follow these steps:

1. Verify the connection string in BenchmarkConfig.cs.
2. Ensure SQL Server is currently running.
3. Check your firewall settings.
4. Confirm the database user has the necessary permissions.

Use SqlSugarScope to implement a singleton pattern that allows you to manage transactions across different methods. You can wrap multiple service calls within a Db.UseTran() block to ensure they all participate in the same transaction.

public static SqlSugarScope Db = new SqlSugarScope(new ConnectionConfig()
 {
            DbType = SqlSugar.DbType.SqlServer,
            ConnectionString = Config.ConnectionString,
            IsAutoCloseConnection = true 
  },
  db=> {
            db.Aop.OnLogExecuting = (s, p) =>
            {
                Console.WriteLine(s);
            };
 });
 
 using (var tran = Db.UseTran())
 {
          
               new Test2().Insert(XX);
               new Test1().Insert(XX);
               ..... 
                ....
                         
             tran.CommitTran(); 
 }

The .Storageable() method provides a convenient way to perform 'Insert or Update' operations. It can handle lists of entities and supports setting page sizes for large datasets.

Db.Storageable(list2).ExecuteCommand();
Db.Storageable(list2).PageSize(1000).ExecuteCommand();
Db.Storageable(list2).PageSize(1000,exrows=> {   }).ExecuteCommand();

Use the .LeftJoin<T> method to perform simple join queries with a fluent syntax. You can chain multiple joins and use .Select to map the results to a specific DTO or view model.

var query  = db.Queryable<Order>()
            .LeftJoin<Custom>  ((o, cus) => o.CustomId == cus.Id)
            .LeftJoin<OrderItem> ((o, cus, oritem ) => o.Id == oritem.OrderId)
            .LeftJoin<OrderItem> ((o, cus, oritem , oritem2) => o.Id == oritem2.OrderId)
            .Where(o => o.Id == 1)  
            .Select((o, cus) => new ViewOrder { Id = o.Id, CustomName = cus.Name })
            .ToList();   

SqlSugar supports automatic table splitting (e.g., by year, month, etc.) using attributes. Use [SplitTable] to define the split type and [SugarTable] to define the naming pattern. A [SplitField] must be designated to tell SqlSugar which field to use for determining the correct sub-table during CRUD operations.

[SplitTable(SplitType.Year)] // Supports year, quarter, month, week and day
[SugarTable("SplitTestTable_{year}{month}{day}")] 
 public class SplitTestTable
 {
     [SugarColumn(IsPrimaryKey =true)]
     public long Id { get; set; }
 
     public string Name { get; set; }
     
     [SplitField] 
     public DateTime CreateTime { get; set; } 
 }

// Querying split tables
 var lis2t = db.Queryable<OrderSpliteTest>()
.SplitTable(DateTime.Now.Date.AddYears(-1), DateTime.Now)
.ToPageList(1,2);

For high-performance data operations, use the .Fastest<T>() API. This provides specialized methods for bulk processing:

• BulkCopy: High-speed insertion of entities or DataTables.
• BulkUpdate: High-speed updates. You can specify the primary key or a custom set of columns to update.
• BulkMerge: High-speed upsert (insert or update).
• BulkDelete: High-speed deletion using .Deleteable<T>(list).PageSize(n).ExecuteCommand().
• BulkQuery: For large data exports, use .ForEach() with a batch size to avoid memory issues.