A Fine Slice Of SQL Server
Jaisen Mathai lays out some changes:
Hey, fellow Apache Kafka® developers! Let’s look at the important updates across Confluent’s client ecosystem, from the core librdkafka to the wrappers for Python, Go, .NET, and JavaScript. The last couple of months have been focused on laying down some solid architectural foundations and adding key quality-of-life features.
I’m curious to see what changes with IBM purchasing Confluent.
Leave a CommentTeo Lachev shares some advice:
Performance is difficult to translate because Power BI Pro/PPU run in a shared capacity, meaning compute resources (v‑cores) are pooled across many tenants and dynamically allocated, whereas Fabric capacities are dedicated, meaning that Microsoft grants specific resources expressed as number of cores and memory. Therefore, Fabric performance is predicable while Pro/PPU might not be, although I’m yet to hear from client complaining about unpredictable performance.
Read on for some high-level thoughts on performance and cost.
Leave a CommentKamil Nowinski provides an overview of the FabricTools Powershell module:
Managing Microsoft Fabric at scale quickly becomes painful if you rely only on the UI. Workspaces, capacities, and tenant-level settings all need repeatable, scriptable management. FabricTools is a community-driven PowerShell module that fills this gap by adding high‑level cmdlets focused on Microsoft Fabric and Power BI administration.
In this post, you will learn what FabricTools is, how to install it from the PowerShell Gallery, and how to list all Fabric workspaces and export them to a CSV file for further analysis.
I was going to say “It looks a lot like DBATools” and then I realized that several of the contributors are DBATools mainstays, so that makes sense.
Leave a CommentBrent Ozar checks out the list:
Whenever a brand spankin’ new version of any software comes out, there are bugs, and SQL Server is no exception. This has led to a mentality where folks don’t wanna install a new version of SQL Server until the first couple of Cumulative Updates come out, hopefully fixing the first big round of bugs.
So… are there bugs this time around?
Read on to see the list. Though I will note that the SQL authentication logins being slower isn’t a bug. It’s a consequence of improving security via PBKDF2 and cranking up the number of iterations. On net, this is a good thing because it makes brute-force password attacks orders of magnitude more difficult while having negligible impact on legitimate users. In the post Brent links, Vlad Drumea has a comment talking about going from sub-1ms to 150ms per login attempt in his tests, and the neat thing about PBKDF2 is that it scales linerally with number of iterations, so as hardware gets faster and faster, you can increase the number of iterations necessary and maintain a fairly standard range of login times.
Leave a CommentDavid Fitzjarrell lays out a comparison:
Depending upon which tool is used query plans can change. There are two provided by Oracle, SQL*Plus and SQL Developer, and how they treat bind variables can alter execution plans. Let’s look into that and see what may be the cause.
SQL*Plus has been around for quite a while and is a very mature product. SQL Developer also has a long history, not quire as long as SQL*Plus but is well beyond the early phases of development. Both are excellent tools, returning reliable and repeatable results, but SQL Developer may take some liberties SQL*Plus doesn’t, especially where bind variables are involved. SQL*Plus and PL/SQL allow the developer to define data types for bind variables, and will pass those values through unchanged. SQL Developer, however, appears to pass such values using a character data type regardless whether the value is a string or numeric, allowing Oracle to ‘decide’ how to optimize the query. This can produce sometimes ‘unexplained’ results with estimates and execution plans.
Read on for an example in which the choice of tool can add a considerable percentage to the expected length of the query. The tricky part here is that this doesn’t mean the query actually takes longer, but that expectations will differ.
Leave a CommentAndy Brownsword checks some data types:
Last week we looked at how expressions are evaluated with the
ISNULLandCOALESCEfunctions. Whilst we’re in the area it’s worth running through how data types are selected for them too. It might have implications with how you implement them.The way these functions choose which data type to return differs, so they aren’t direct swap outs for each other, and you can’t simply ‘upgrade’ an
ISNULLtoCOALESCEand expect the same result.
Read on to see how the two behave under different circumstances with changing data types.
Leave a CommentJoe Sack digs into a common problem in vector search. First up is a description of the problem:
I embedded two queries: “home with pool” and “home without pool.” The cosine similarity was 0.82. The embedding model treats negated queries as nearly identical to their positive counterparts.
For comparison, completely unrelated queries (“home with pool” vs “quarterly earnings report”) scored 0.13.
In my last post, I showed that vector search treats “home with pool” and “home without pool” as nearly identical (0.82 similarity). Bi-encoders struggle with negation.
Read on to learn how cross-encoders can help, but they come at a significant cost. Joe also describes a pattern that can minimize the total pain level when using cross-encoders.
Leave a CommentGreg Low shares some thoughts:
Upcoming processors are likely to have even more cores than now. Have you ever tried to write multiprocessor-style code? A friend of mine recently said that he learned some of this style of coding but later when he came back to it, he realised how much he thought he knew but didn’t.
For languages like T-SQL, we don’t have inherent support for multi-threading. In fact, the only trace I can see of this in T-SQL today is the ability to have multiple readers on a service broker queue.
In general, we haven’t needed this because SQL Server systems constantly have many requests thrown at them concurrently anyway and there is a natural style of parallelism happening.
I’d take it one step further. T-SQL, as a reasonable attempt at a 4th-generation programming language, abstracts away the need to define what should or should not be parallel. That’s the job of the database engine. We tell it what the end result should look like and let the engine figure out the details.
I do like the idea that Greg mentions of running stored procedures asynchronously. That’s something we typically need a separate programming language and some calling code to implement. Either that or a larger number of SSMS tabs.
Leave a CommentFabiano Amorim makes note of a security concern:
Privilege escalation in SQL Server isn’t just theory – it can happen through everyday maintenance jobs. This article demonstrates how a user with roles like
db_ownerordb_ddladmincan exploit replication cleanup processes to gain sysadmin rights, and why monitoring trigger creation and job behavior is critical for security.
Replication is one of those things people tend not to understand very well, including the necessary permissions. It’s a lot easier simply to say, “Here’s sysadmin” because that actually works instead of giving you a cryptic error you can barely troubleshoot and that’s only thanks to a Repltalk article from 2009. And heaven help you if you’re looking at merge replication.
But as far as the article goes, I won’t say that it’s much ado about nothing. What I will, however, say is that your account needs to be db_owner or db_ddladmin first, and that does mitigate a fair amount of the risk.
Leave a CommentTomaz Kastrun continues an advent of SQL Server 2025. Day 22 looks at the UNISTR() function:
UNISTR() function is a new T-SQL function in SQL Server 2025. It will help you with unicode string literals (e.g.: special characters, emoji, special language alphabets and others) by letting you specify the unicode encoding value of characters in the string.
Difference between NCHAR and UNISTR is that latter will provide more flexibility and ways of handling multiple unicode characters and even escape sequences. You can also define a custom escape character to perform the necessary conversion of Unicode values into a string character set.
Day 23 looks at a new way of concatenating and compound assigning:
Two new features are available in SQL Server 2025 for string operations; both for string concatenation.
The || and ||= combo are basically + and += for string, but it brings T-SQL in alignment with ANSI SQL. I’d still recommend using functions like CONCAT() for NULL-safety, or CONCAT_WS() for NULL-safety plus automatic separator addition, but it does fix a longer-standing pain point around platform compatibility.