SQL Server 2025’s first release candidate arrived August 22, 2025, and it’s a clear signal that Microsoft intends to keep its flagship database engine not just relevant but foundational for the next generation of on-premises applications. RC0 isn’t merely a stability checkpoint; it ships a raft of AI primitives, long-requested T-SQL enhancements, and a new secure-by-default posture that changes the calculus for architects who’ve been eyeing vector databases or bolting on third-party tooling. Adoption of the preview has been brisk—Microsoft reports downloads running at twice the pace of SQL Server 2022—and early customers are already vetting built‑in AI, native JSON, and regular expression support for production-scale workloads.

A Measured Path to Innovation: PREVIEW_FEATURES

RC0 debuts a database‑scoped configuration called PREVIEW_FEATURES that lets teams safely experiment with cutting‑edge capabilities without destabilizing the entire instance. Unlike the traditional trace flags that DBAs have used for decades to toggle internal engine behaviors, this switch is designed for developers and scoped to a single database. You flip it on with ALTER DATABASE SCOPED CONFIGURATION SET PREVIEW_FEATURES = ON; and a curated set of preview innovations—vector indexing, AI text chunking, change event streaming—becomes available. Microsoft stresses that enabling it does not render the database unsupported, though any persistent objects created (like a preview vector index) must be cleaned up before you turn the flag off. It’s an opt‑in model that mirrors cloud service feature gating and answers a perennial complaint that on‑prem shops had to choose between stability and early access.

AI Where Your Data Lives: Vectors, Models, and Chunking

Forget the separate vector database. SQL Server 2025 bakes AI directly into T‑SQL with a native vector data type, the VECTOR_DISTANCE function, and an approximate nearest‑neighbor index powered by Microsoft’s DiskANN algorithm. Together they enable sub‑second similarity searches across billions of rows without moving data outside the engine. New functions AI_GENERATE_EMBEDDINGS and AI_GENERATE_CHUNKS let you create embeddings or split text right in the database, while CREATE EXTERNAL MODEL registers local ONNX models, Azure OpenAI, OpenAI, or Ollama endpoints. From there, a simple SELECT can call an embedding model and insert vectors into a column—all auditable, back‑up‑able, and governed by the same security model as the rest of your data. RC0 also walks Windows shops through enabling REST endpoints, registering a local ONNX model, and monitoring calls via Extended Events, so skilled DBAs can prototype a full retrieval‑augmented generation (RAG) pipeline without provisioning a separate inference tier.

Developer Delight: Native JSON and T‑SQL Regex

Two decades of community wish‑list items land in SQL Server 2025. First, a native JSON data type stores documents in a binary‑optimized format and pairs with a new JSON index that accelerates JSON_VALUE, JSON_PATH_EXISTS, and JSON_CONTAINS queries. While the JSON type is already generally available in Azure SQL, the on‑premises preview in RC0 comes with some noted limitations around replication and bulk import—so DBAs should validate carefully before wide rollout. Second, T‑SQL gains REGEXP_LIKE, REGEXP_REPLACE, and REGEXP_SUBSTR, finally making complex pattern matching a first‑class citizen. In RC0, REGEXP_LIKE becomes SARGable, meaning queries can leverage appropriate indexes, and the functions now support large object types like varchar(max). The engine team’s attention to SARGability signals a pragmatic understanding that performance cannot be an afterthought.

Secure by Default: TLS 1.3 and TDS 8.0

RC0 pushes encryption into the foreground. On Linux, TLS 1.3 is now enabled by default, and across all platforms SQL Server 2025 adopts TDS 8.0, which begins encryption at pre‑login. SQL Agent jobs and Linked Servers now require encrypted connections, and the wave is extending to replication and high‑availability features. The result: fewer silent downgrades to weak ciphers and more explicit failures when an outdated client can’t negotiate a strong handshake. For Windows shops, this means inventorying driver versions ahead of an upgrade is essential. The new defaults also dovetail with Azure Arc‑enabled managed identities, reducing the sprawl of connection strings and embedded secrets.

Linux Momentum and Ubuntu 24.04

Linux adoption for SQL Server continues to climb, and RC0 adds preview support for Ubuntu 24.04 LTS—a welcome baseline for containers, WSL2 environments, and admins who want a modern dev/test stack. Microsoft is clear this is evaluation-only for now, with production guidance remaining on supported 2022 images, but it signals a commitment to keeping pace with the ecosystem. PolyBase connectivity to Azure Storage now supports managed identity authentication, a boon for passwordless patterns, and Fabric mirroring benefits from Resource Governor integration that lets you dedicate workload groups to ingestion, transformation, and synchronization.

Under‑the‑Hood Engine Improvements

Beyond the marquee features, RC0 polishes several operational rough edges: CE_FEEDBACK for persisted expressions now survives restarts and failovers, stabilizing plan behavior; time‑bound Extended Events sessions auto‑stop after a set horizon; tempdb space resource governance caps consumption per workload group, greatly reducing the blast radius of runaway queries; and type‑adjustment tweaks like JAROWINKLER return values smooth out edge cases. Together they address real‑world papercuts that, for many DBAs, matter as much as the headline AI story.

Why Windows Shops Should Care Immediately

RC0 redefines what a database engine can do without bolt‑on stores. Built‑in AI means embeddings, indexes, and inference orchestration stay inside the backup/recovery boundary, which directly reduces operational overhead. The PREVIEW_FEATURES switch eliminates the all‑or‑nothing dilemma of early adoption, giving DBAs per‑database control and a clear exit strategy. End‑to‑end encryption strengthens your security posture while simultaneously surfacing outdated clients that would have been a liability later. And the Windows‑first AI walkthroughs let you evaluate retrieval‑augmented search and model invocation using only tools already in your stack.

A Practical Evaluation Plan for RC0

  1. Spin up a Windows or Linux sandbox instance; verify your client tooling (SSMS, SqlClient) supports TLS 1.3 and TDS 8.0.
  2. Create a dedicated database for experimentation and enable PREVIEW_FEATURES = ON only there.
  3. Set database compatibility to 170 to unlock REGEXP_LIKE and related SARGability improvements.
  4. Enable external REST endpoints with sp_configure and register a local ONNX or Ollama model; add an XEvent session to trace calls.
  5. Build an end‑to‑end vector workflow: generate embeddings, create a DiskANN index, and run hybrid searches mixing vector distance and standard SQL filters.
  6. Migrate a non‑critical JSON string column to the native type, add a JSON index, and benchmark predicate performance.
  7. Trial regex queries against messy data; inspect execution plans to confirm index usage and SARGability.
  8. If using Fabric mirroring, carve out a Resource Governor pool for ingestion/sync workloads and observe resource isolation under load.
  9. For cloud‑connected scenarios, Arc‑enable the host and test managed identity for PolyBase and storage—no more secrets in connection strings.

Strengths That Stand Out

  • AI without sprawl. Vector and model primitives collapse the architecture stack, keeping retrieval‑augmented workloads under the same governance umbrella.
  • Preview without panic. Database‑scoped feature flags align on‑prem processes with cloud‑style experimentation, reducing risk.
  • Security that denies before you even ask. TDS 8.0 and TLS 1.3 force strong encryption at the TCP handshake, exposing weak clients early.
  • Developer ergonomics delayed no longer. Native JSON and regex eliminate round‑trips to CLR or application code, and early SARGability work shows the engine team sweats real‑world performance.
  • Operational maturity. Tempdb caps and persisted CE feedback translate directly into fewer late‑night pages and more predictable failovers.

Risks and Caveats

  • Preview features are still preview. Persisted objects created with PREVIEW_FEATURES on may need to be dropped before turning the flag off; treat them as non‑production until GA guidance changes.
  • JSON is powerful but young on‑prem. Replication, CDC, and bulk‑import limitations remain, so validate thoroughly before large‑scale schema shifts.
  • Regex can be a CPU foot‑gun. SARGability helps, but poorly written patterns will still thrash; always profile real plans and verify index utilization.
  • Client compatibility is not optional. Older drivers and middleware may choke on TDS 8.0/TLS 1.3 defaults; inventory your connection strings and plan phased cutovers.
  • Fabric mirroring resource planning requires care. Under‑provision the dedicated pool and OLTP suffers; over‑provision and you starve other workloads.

How RC0 Changes Day‑One Architecture Conversations

  • Do we need a separate vector database? Often, no. For most retrieval‑ranking use cases, SQL Server’s DiskANN index, vector type, and rich filtering keep everything in one engine.
  • How do we safely test AI features? Flip PREVIEW_FEATURES in a sandbox database, register a local model, and gate outbound calls—no data leaves your compliance boundary.
  • Can we get near‑real‑time analytics without a new pipeline? Fabric mirroring plus Resource Governor will cover many scenarios, letting product teams have fresher insights while DBAs retain control.

Verdict

SQL Server 2025 RC0 threads a tricky needle: it’s assertive about AI and developer experience, yet conservative where it counts—encryption defaults, scoped experimentation, and clear guardrails around preview features. The inclusion of a vector database’s best tricks alongside JSON and regex closes gaps that have pushed teams toward extra components and glue code. And by hardening connectivity and offering managed identity via Arc, the platform acknowledges modern security expectations instead of punting them to documentation. There’s still work ahead: production‑grade JSON guidance, careful regex performance education, rigorous client compatibility testing, and clear upgrade playbooks for Fabric mirroring at scale. But for Windows shops that have been waiting for a reason to kick off serious lab testing, RC0 is the right release candidate to install, script, and start benchmarking today.