feat: add packet_size configuration for LOGIN7 message

[johndauphine]

Summary

Add the ability to configure the TDS packet size in the LOGIN7 message. Larger packet sizes can significantly improve bulk insert performance by reducing network round-trips and protocol overhead.

Motivation

While working on a high-throughput data migration tool, we discovered that the default 4KB packet size was a significant bottleneck for bulk insert operations. Benchmarking showed:

Packet Size	Time (19.3M rows)	Throughput
4KB (default)	~186s	104K rows/sec
16KB	~108s	178K rows/sec

This is a 42% improvement in bulk insert performance simply by increasing the packet size.

For comparison, Go's go-mssqldb driver also defaults to 4KB packets, but exposes configuration. After this change, Rust/tiberius performance matches or exceeds Go for bulk operations.

Changes

• Add packet_size: Option<u32> field to Config struct
• Add packet_size(&mut self, size: u32) setter method with documentation
• Add get_packet_size(&self) -> Option<u32> getter method
• Wire up packet_size to LoginMessage in the connection flow
• Add packet_size(&mut self, size: u32) setter to LoginMessage

Example Usage

let mut config = Config::new();
config.host("localhost");
config.packet_size(32767);  // Request 32KB packets (server may negotiate lower)

let tcp = TcpStream::connect(config.get_addr()).await?;
let mut client = Client::connect(config, tcp.compat_write()).await?;

Technical Notes

• Default remains 4096 bytes for backwards compatibility
• Valid values are 512 to 32767 bytes per TDS spec
• The server may negotiate a different size (e.g., SQL Server on Linux caps at ~16KB)
• The negotiated size is communicated via ENV_CHANGE token and stored in Context

Test Plan

• Tested against SQL Server 2022 on Linux (Docker)
• Verified packet size negotiation via ENV_CHANGE token
• Benchmarked bulk insert performance improvement
• Existing tests pass (cargo test --features rustls)

🤖 Generated with Claude Code

[johndauphine]

Adding some cross-references in case they help prioritization:

• Query Performance #294 — community report of tiberius bulk reads running ~2x slower than C#. The discussion explores fetch strategies but never lands on a packet-size lever.
• Performance improvement - handling buffers in plp.rs #226 — separate buffer-handling fix reporting a ~3x speedup on varchar reads (open since 2022).

This PR is the LOGIN7 piece of that same throughput story. The 42% improvement in the table above came from our high-throughput data migration tool (Rust → Postgres), where the 4KB default was the dominant bottleneck on the MSSQL read side. With 16KB packets the Stack Overflow 2010 dataset (19.3M rows across 10 tables) goes from ~104K to ~178K rows/sec end-to-end, putting Rust + tiberius at parity with go-mssqldb on the same workload — the only remaining difference between the two drivers here is configurability.

The change is minimal (3 files, +32/-0), backwards compatible (default unchanged), and the server-negotiated value still flows through the existing ENV_CHANGE path so older servers behave identically. Happy to rebase or add tests if anything is blocking review.