The interesting and challenging aspect of this setup is ensuring that the encryption and decryption remains intact after a failover.

This challenge originates from SQL Server’s encryption hierarchy. In a typical setup, the Service Master Key (SMK) on server level protects the Database Master Key (DMK) on database level. The Database Master Key, in turn, protects certificates and asymmetric keys, while certificates are commonly used to protect symmetric keys. These symmetric keys may then be used by the application to encrypt and decrypt sensitive data.

When a failover to a secondary replica occurs, the Service Master Key (SMK) is no longer the same as on the previous primary replica. Since the Database Master Key (DMK) is typically encrypted by the local Service Master Key, SQL Server may no longer be able to open the DMK transparently after the failover. As a result, any encryption objects that depend on the DMK, such as certificates and symmetric keys, may become inaccessible, potentially causing application failures when encrypted data needs to be read or written.

Let’s now explore the built-in approaches in SQL Server to ensure that the encryption hierarchy remains functional across replicas and that applications continue to operate seamlessly after a failover.

First, let’s create a test database and a Database Master Key:

-- Create Demo DB
CREATE DATABASE TestDMK;
GO
--Backup DB
BACKUP DATABASE TestDMK
TO DISK = 'C:\SQLServer_mnt\BACKUP\TestDMK.bak';
go
-- Create Database Master Key
CREATE MASTER KEY
ENCRYPTION BY PASSWORD = 'MyVeryStrongPassword_123!';
GO
-- Check Master Key
SELECT DB_NAME() as DB, *
FROM sys.symmetric_keys
WHERE name = '##MS_DatabaseMasterKey##';
GO

It is worth noting that you can verify whether a Database Master Key is also encrypted by the Service Master Key by querying the sys.databases catalog view. When a Database Master Key is created, SQL Server typically adds encryption by the Service Master Key automatically. This behaviour can be changed by explicitly removing the Service Master Key encryption.

select is_master_key_encrypted_by_server, * from sys.databases where name = 'TestDMK'

With the Database Master Key in place, let’s create a certificate and a symmetric key that will be used throughout the remainder of this demonstration.

CREATE CERTIFICATE [mainDBCert] --> This cert is going to be encrypted by the dmk
WITH SUBJECT = 'test Cert';
go
CREATE SYMMETRIC KEY mainKey
WITH ALGORITHM = AES_256
ENCRYPTION BY CERTIFICATE mainDBCert;
go
SELECT * FROM sys.certificates;
SELECT * FROM sys.symmetric_keys WHERE name <> '##MS_DatabaseMasterKey##';
SELECT * FROM sys.symmetric_keys;
go

To demonstrate the encryption and decryption process, let’s create a simple table that will contain sensitive information and insert some data.

--create table with sensitive data
CREATE TABLE CreditCards
(
    Id int,
    CreditCardNr varbinary(max),
    CVC varbinary(max),
    ExpirationDate varbinary(max)
);
go
--open symmetric key
OPEN SYMMETRIC KEY mainKey
DECRYPTION BY CERTIFICATE mainDBCert;
--insert sensitive data
INSERT INTO CredîtCards
VALUES
(
    1,
    EncryptByKey(Key_GUID('mainKey'), '1234-5678-9012-3456'),
    EncryptByKey(Key_GUID('mainKey'), '123'),
    EncryptByKey(Key_GUID('mainKey'), '1233')
);
CLOSE SYMMETRIC KEY mainKey;
GO
Select * from CreditCards

If we query the table without opening the symmetric key and decrypting the values, we can see that we won’t see the data.

--select data without decryption
SELECT
    Id,
    CONVERT(varchar(50), CreditCardNr) AS CreditCardNr,
    CONVERT(varchar(10), CVC) AS CVC,
    CONVERT(varchar(10), ExpirationDate) AS ExpirationDate
FROM CreditCards;

However, if we open the symmetric key first and use it to decrypt the data, we are able to retrieve the original sensitive information:

OPEN SYMMETRIC KEY mainKey
DECRYPTION BY CERTIFICATE mainDBCert;
GO
SELECT
    Id,
    CONVERT(varchar(50), DecryptByKey(CreditCardNr)) AS CreditCardNr,
    CONVERT(varchar(10), DecryptByKey(CVC)) AS CVC,
    CONVERT(varchar(10), DecryptByKey(ExpirationDate)) AS ExpirationDate
FROM CredîtCards;
GO
CLOSE SYMMETRIC KEY mainKey;
GO

Now let’s add our database to an Always On Availability Group to provide high availability and disaster recovery. If you follow the Availability Group wizard, you may notice that the wizard asks you to enter a password. What the wizards is asking for here is the password of the Database Master Key (DMK). The DMK protects the certificate in our encryption hierarchy, and the certificate, in turn, protects the symmetric key used to encrypt and decrypt the sensitive data.

On the right-hand side of the wizard, there is a small and easily overlooked text box where you can enter the Database Master Key password.

And now comes the tricky – and at the same time somewhat surprising – part. If you use automatic seeding, which is my preferred option whenever the database size allows it, the process will skip the part where the Master Key password is verified and applied on the secondary replicas.

As a result, when a failover occurs, SQL Server would no longer be able to open the Database Master Key (DMK) transparently on the new primary replica. Consequently, the application would no longer be able to encrypt or decrypt data unless the Database Master Key is explicitly opened first with the password.

In such a scenario, the issue can be resolved by storing the Database Master Key password as a credential on each replica using the sp_control_dbmasterkey_password stored procedure. SQL Server can then use this credential to automatically open the Database Master Key after a failover, allowing the encryption hierarchy to remain intact and ensuring that certificates, symmetric keys, and encrypted data remain accessible transparently.

!!Note that you must do that on each replica!!

sp_control_dbmasterkey_password @db_name = N'TestDMK'
    , @password = N'MyVeryStrongPassword_123!'
    , @action = N'add';
select * from sys.master_key_passwords;
select * from sys.credentials;

Once the credential has been created, SQL Server is again able to open the Database Master Key transparently. As a result, the application can continue to encrypt and decrypt data without having to explicitly open the Master Key with the password.

There is also an option by which SQL Server automatically creates the Database Master Key credential across all replicas when a database is joined to an Availability Group. This happens when “Full Database Backup and Log Backup” is selected as the initial data synchronization option in the Availability Group wizard.

To demonstrate this, let’s remove the previously created credential using the same stored procedure.

sp_control_dbmasterkey_password @db_name = N'TestDMK'
    , @password = N'MyVeryStrongPassword_123!'
    , @action = N'drop';
select * from sys.master_key_passwords;
select * from sys.credentials;

Now, let’s select “Full Database and Log Backup” as the initial data synchronization option in the Availability Group wizard.

As you can see, the process is no longer skipping the Database Master Key password validation step.

In the summary, you can see that the process automatically created the Database Master Key password credential on each replica.

If you check the credentials on each replica afterwards, you can verify that they were created automatically.

As the Database Master Key password credential has been added to all replicas, SQL Server can transparently open the DMK after a failover. As a result, the application can continue to encrypt and decrypt data without having to explicitly open the Database Master Key.

But one question still puzzles me: why the same operation isn’t performed automatically when automatic seeding is used?

Honestly, I have no clue yet. If you know more let me know it in the comments section. I’d love to learn more about it.

Thanks for reading – Hocine 😉

L’article SQL Server Always On Availability Groups and Database Master Keys: A Hidden Failover Pitfall est apparu en premier sur dbi Blog.

• Calling GPT-4o from SQL Server to generate product content: https://www.dbi-services.com/blog/lift-your-application-in-the-age-of-ai-with-sql-server-2025/
• Generating & storing embeddings in SQL Server 2025: https://www.dbi-services.com/blog/sql-server-2025-generate-data-embeddings-for-semantic-search/
• Accelerating Semantic Search workloads with vector Indexes: https://www.dbi-services.com/blog/sql-server-2025-vector-indexes-semantic-search-performance/

In this post now, we will combine some of these functionalities to implement a simple RAG based shopping assistant with SQL Server 2025 (Preview).

What is RAG?

But first of all I will introduce you in the concept of RAG. As you may already noticed in recent years, AI chat models are great. They are able to understand your prompts, they can perform reasoning to “think” about what you ask them and they can provide you an individual answer. But the model alone is limited to the data on which it was trained on.

So when I ask a chat model like GPT-5 a very general question like “What is the capital of Australia?” the model is able to answer this question without any problem because it’s general knowledge and the model certainly came into touch with this knowledge through its training data. But when I ask the model something which is only known through access on specific ( usually private) data sources  the model is not able to answer such a question at least not alone. For example  when I ask the model how many vacation days  I have left for this year  the model  is obviously not able to answer such a question because such information’s are stored in  company internal tools:

This  is the point where Retrieval  Augmented Generation (RAG) comes into play. RAG is an approach that searches external data sources for information relevant to the user’s prompt. The retrieved data is then used to augment the generation process of the AI model, allowing it to produce a context-aware and more accurate response.

And this is what we will implement within this blog post. We will build a simple chat service  which will help the customers of the ShopAI Online Shop to find the product of their desire.

RAG Architecture:

Let’s take a look at the RAG  architecture for our purpose.  Therefore take a look at the  schema below  and on the numbers which are representing steps in the RAG-process:

1. The customer sends a prompt  to the ShopAI chat service where he describes which product he or she is looking for.
2. The prompt is taken by the chat service and is sent to the embedding  model hosted on azure to generate  and return an embedding for that prompt.
3. The embedding of the customers prompt is then used to perform a semantic search on the products data in the ShopAI database.
4. The Top N semantic matching products are then sent to the chat model hosted on Azure for augmenting the generation of the response for the customers prompt.
5. The augmented response is then sent to the customer.

We will be able to handle the whole data logic inside T-SQL with the latest features of SQL-Server 2025 (Preview).

Preparing the AI Models:

So far so good. Let’s start now with the practical implementation of our vision.

The AI models I’m using are the gpt-4o-mini model for the chat completion tasks and the text-embedding-3-small model to create embeddings for the users prompt. Embeddings for product data are already persisted in our database (refer to the earlier blog for details). When generating embeddings for user queries, use the exact same embedding model and settings used for the stored data.

To learn how to deploy an AI model in Azure you should also check out my previous blog posts where I’m guiding you through the process. For this article my models are already deployed in Azure AI Foundry:

To use now the models inside T-SQL we have to create first a database scoped credential for the chat completion model. You can do that with the following statement. You’ll find the API key inside Azure AI Foundry (Check out the previous Blog posts for detailed instructions):

Use ShopAI
Go
-- Create database scoped credential:
CREATE DATABASE SCOPED CREDENTIAL [https://shopai-blog.openai.azure.com/openai/deployments/gpt-4o-mini/] /* always youse an url which is more generic*/
    WITH IDENTITY = 'HTTPEndpointHeaders', secret = '{"api-key":"YOUR-API-KEY"}';
GO

Then we will do the same for the embedding model:

Use ShopAI
Go
-- Create database scoped credential:
CREATE DATABASE SCOPED CREDENTIAL [ https://shopai-blog.openai.azure.com/openai/deployments/text-embedding-3-small/] /* always youse an url which is more generic*/
    WITH IDENTITY = 'HTTPEndpointHeaders', secret = '{"api-key":"YOUR-API-KEY"}';
GO

And then we will register our embedding model to be able to generate data embeddings with the T-SQL built in functions:

Use ShopAI
-- Create EXTERNAL MODEL
CREATE EXTERNAL MODEL OpenAITextEmbedding3Small
AUTHORIZATION dbo
WITH (
      LOCATION = 'https://shopai-blog.openai.azure.com/openai/deployments/text-embedding-3-small/embeddings?api-version=2023-05-15',
      API_FORMAT = 'Azure OpenAI',
      MODEL_TYPE = EMBEDDINGS,
      MODEL = 'text-embedding-3-small',
      CREDENTIAL = [https://shopai-blog.openai.azure.com/openai/deployments/text-embedding-3-small/],
      PARAMETERS = '{"Dimensions":1536}'
);

RAG Stored Procedure:

As we have now an AI model for chat completion and one for generating data embeddings, we are now ready to write our code for processing the data logic. We will handle all the data logic and interaction with the AI models within a T-SQL stored procedure. I will explain the stored procedure I wrote for that in this chapter.

We have two Input Parameters which is the @SearchText parameter and the @ChatHistory Parameter. The @SearchText parameter represents the input text which the user is giving to our shopping assistant and the @ChatHistory is representing the history of the conversation and is per default set to NULL. We will handle the history of the conversation outside of the stored procedure.

Then the stored procedure will generate an embedding of the user query which is stored in the @SearchText variable and it will perform an exact vector distance search based on the product catalog data and the user query. Then it stores the top 5 findings as a list of JSON objects with the attributes product name, product description and product price:

In the next step the Stored procedure generates a prompt for the AI chat completion model without a previous chat history (in case the @ChatHistory parameter is NULL):

If there is a previous chat history (the @ChatHistory parameter is not NULL) the stored procedure is generating a prompt which is also including the provided chat history data:

And finally the stored procedure calls the API of the chat completion model with the generated prompt and returns/selects the response from the model:

The process of RAG isn’t that complicated, right? To recap:

1. You take the user query and generate an embedding for it.
2. You use that embedding to semantically search your relevant context data.
3. You prompt a chat completion model, augmenting your prompt with the retrieved context.

Of course, in practice things can get more complex but at a high level, that’s the essence of how RAG works.

Let’s test the stored procedure with a sample user request and let’s see if we get a nice answer back with some product recommendations:

Not bad for some few lines of code. This is the text I got back for my request:

Shop Assistant Web app

So we have now a stored procedure which is able to generate context aware product recommendations. Now let’s wrap that up in a better-looking front end.

I’m building that it in Python with Streamlit, a framework for quickly spinning up web apps, perfect for rapid prototyping. Make therefore sure that you have streamlit installed in your environment. So let’s take a look at the python code.

First I’m importing the modules which we need for our ShopAI Assistant. This is “pyodbc” for interacting with our database, “os” to read environment variables from operating system, “streamlit” itself, the “time” module to work efficient with time data, the “load_dotenv” method to load our environment variables into the operating system and “json” to work with json data:

Then I’m creating a .env file in my project directory to store our environment variables, which are the Server and Instance Name where our ShopAI database is running on, a SQL user with a password to connect to the database (make sure the user exists and has the appropriate rights):

In my python code I then wrote a function as a wrapper around the SQL stored procedure:

Then I’m loading the environment variables from our file into the operating system and I’m building our pyodbc connection string:

Then we continue with Streamlit. We start by initializing the first assistant message in the st.session_state variable, a built-in Streamlit object that stores session data such as the conversation history. After that, we loop through all messages in the session state and display them to the user. Finally, we wait for new user input through the chat input field, so the conversation can continue interactively.

Next, we handle the user input. When the user enters a message, it’s captured by st.chat_input().

We then check if there are already previous messages stored in st.session_state. If yes, we convert the chat history (except for the very first assistant message) into JSON format and store it in the variable chat_history. Otherwise, we set chat_history to None. We do this for handling the conversation history inside python and pass it to the SQL stored procedure.

We will then construct the input parameters for our get_product_recommendation function and we store the parameters inside a tuple which we call “p”.

Then we append and display the user prompt to the chat front end.

Finally we invoke the SQL stored procedure through our python function and we will display the response from the AI model in a typing like manner:

Testing the ShopAI assistant

We have now wrote a stored procedure for processing the data logic and interacting with the gpt embedding and chat completion model and we have a simple Streamlit app to handle the conversation history and for the front end.

Let’s test what we did. To start the Streamlit web app I simple run the command “streamlit run app.py2:

A browser window should open and you will be able to see the front end of the shopping assistant:

Fine! let’s ask him who he is and how he can helps us …

Looks like he knows his purpose😉 let’s see if he is able to find the products of our desire. I’m looking for some sport shoes …

Awesome! We are getting a suitable response! The only weakness I see is, that we are getting twice the product “New Look Sneakers (Black)” recommended but with different prices.

But when looking at the data below it’s actually not the fault of our assistant because we have this product two times in our product catalogue. Good point to see how data quality matters 😉:

I’m interested in the “Skechers Sneakers (Black)” but I’m not fully convinced yet. Let’s see if the assistant is doing a great job convincing me:

Sounds good for my! I’m totally convinced that these sneakers would perfectly match to my desire. Assistant you made a good job!

Key Takeaways

As you’ve seen in this post, we were able to easily build an AI shopping assistant, with all the data processing and RAG logic running directly inside SQL Server 2025 (Preview)! We only used python for handling the conversation history and for a nice looking front end with Streamlit.

If you are looking for more inspiration regarding this topic I can highly recommend you to visit the following GitHub page from Microsoft: https://github.com/Azure-Samples/azure-sql-db-chatbot/

Note that you will find all the code I wrote and explained in this blog on my GitHub: https://github.com/HocineMechara/ShopAI-AIAssistantBlog.git

Let me know your thoughts on AI, and especially on RAG, in the comments section, I’d be delighted to read your insights and discuss this topic further!

Thanks for reading, Hocine 😉

L’article SQL-Server 2025: Building a RAG Shopping Assistant with T-SQL est apparu en premier sur dbi Blog.

Exact and Approximate Search:

First, let’s talk about the different functions available in SQL-Server 2025 Preview and the concepts behind them.

If you read my last blog post, you may remember that we used the VECTOR_DISTANCE() function to search for black pants I might wear during my summer vacation. This function calculates the Exact Nearest Neighbors (ENN) for the vector of the search text. In practice, it calculates the vector distance between the given vector and all other vectors, then sorts the results and returns the top (K-) Nearest Neighbors (NN). In the context of OLTP systems and B-tree indexes, you can compare this process to an index scan operation with additional sorting and computation overhead. As you can already anticipate, calculating the Exact Nearest Neighbors can be quite resource-intensive depending on the amount of data. In the Microsoft documentation, the general recommendation is to perform an exact search when you have fewer than 50’000 vectors – noting that you can also prefilter the number of vectors using predicates.

When working with large vector datasets the VECTOR_SEARCH() function comes into play. Instead of scanning the entire dataset and calculating the distance for each vector, the VECTOR_SEARCH() function approximates the nearest neighbors (ANN) for a given vector using vector index structures. While ANN requires far fewer resources than exact K-NN, it comes with a trade-off in terms of accuracy.

This trade-off in accuracy is measured by the recall value. Recall represents the overlap between the approximate neighbors found and the true K-NN set. For example, if we search for the 10 nearest neighbors of a vector and ANN returns 7 results that are also in the exact K-NN set, the recall would be 0.7 (7 /10 = 0.9). The closer the recall is to 1, the more accurate the ANN results are.

In SQL-Server 2025 Preview, a vector index is required to perform ANN searches with the VECTOR_SEARCH() function. SQL-Server 2025 Preview uses the DiskANN algorithm to create these graph-based vector indexes. DiskANN is designed to leverage SSDs and minimal memory resources for storing and handling graph indexes, while still maintaining high accuracy with a recall of around 0.95.

Note: While the VECTOR_DISTANCE  function is available in SQL-Server 2025 preview and Azure SQL, the VECTOR_SEARCH function is currently only available in SQL-Server 2025 Preview.

You can get more information’s from Microsoft’s documentation.

Let’s take a practical look at the features:

First of all we have to enable some trace flags to be able to use the preview features:

	DBCC TRACEON(466, 474, 13981, -1);
	DBCC TRACESTATUS;

Then I’m creating a vector index on my “embedding” column in my “dbo.products” table. I’m using the DiskANN algorithm which is currently the only one which is supported. Further I’m using the “cosine” metric for the similarity calculation. You can also use “Euclidean Distance” or “Dot Product” as similarity metrics.

CREATE VECTOR INDEX vec_idx ON [dbo].[products]([embedding]) 
WITH (METRIC = 'cosine', TYPE = 'diskann');

Then we are ready to go and we can test the VECTOR_SEARCH function with the query below:

--Test Approximate Search

DECLARE @SemanticSearchText Nvarchar(max) = 'Im looking for black pants for men which I can wear during my summer vacation.'
DECLARE @qv VECTOR(1536) = AI_GENERATE_EMBEDDINGS(@SemanticSearchText USE MODEL OpenAITextEmbedding3Small);

SELECT
		product_id,
		product_name, 
		Description,
		price,
		s.season,
		g.gender
		FROM
			VECTOR_SEARCH(
				TABLE = [dbo].[products] AS p, 
				COLUMN = [embedding], 
				SIMILAR_TO = @qv, 
				METRIC = 'cosine', 
				TOP_N = 10
			) AS vs
		inner join dbo.season s on p.season_id = s.season_id
		inner join dbo.gender g on p.gender_id = g.gender_id
	ORDER BY vs.distance

As you can see we are getting a pretty accurate result. Lets compare the results of the exact search using the VECTOR_DISTANCE function and the approximate search using the VECTOR_SEARCH function with the code below:

DECLARE @SemanticSearchText Nvarchar(max) = 'Im looking for black pants for men which I can wear during my summer vacation.'
  
    DECLARE @qv VECTOR(1536) = AI_GENERATE_EMBEDDINGS(@SemanticSearchText USE MODEL OpenAITextEmbedding3Small);
 
 --Exact Search

    SELECT TOP(10)
		product_id as ENN_product_id,
		product_name as ENN_product_name, 
		Description as ENN_description,
		price as ENN_price,
		s.season as ENN_price,
		g.gender as ENN_gender,
		VECTOR_DISTANCE('cosine', @qv, embedding) AS distance 
	FROM dbo.products p
		inner join dbo.season s on p.season_id = s.season_id
		inner join dbo.gender g on p.gender_id = g.gender_id
		ORDER BY   distance;

--Approximate Search

	SELECT
		product_id as ANN_product_id,
		product_name as ANN_product_name, 
		Description as ANN_Description,
		price as ANN_price,
		s.season as ANN_season,
		g.gender as ANN_gender
		FROM
			VECTOR_SEARCH(
				TABLE = [dbo].[products] AS p, 
				COLUMN = [embedding], 
				SIMILAR_TO = @qv, 
				METRIC = 'cosine', 
				TOP_N = 10
			) AS vs
		inner join dbo.season s on p.season_id = s.season_id
		inner join dbo.gender g on p.gender_id = g.gender_id
	ORDER BY vs.distance

As you can see, we are getting a fairly accurate ANN result. This corresponds to a recall of 0.8, since only the products with IDs 1292 and 2167 are missing from the exact search result set:

Of course, in this example we only have 3’000 products in our database, so the savings in resource consumption when using ANN are not very significant. However, when processing much larger datasets, using ANN becomes highly relevant.

Limitations with Vector indexes – in SQL-Server 2025 Preview

Interesting to know is that tables with a vector index are read only in the preview edition so you can’t manipulate data at the moment:

	update dbo.products
	set price = price * 0.8
	where product_id = 13

In addition to support a vector index, the table must have a clustered index defined on a single column that is a primary key with the integer data type.  In the preview edition, vector indexes do also not support partitioning and are not replicated to subscribers when using replication. According to Microsoft, these limitations apply to the current preview edition of SQL Server 2025. I’m excited to see if these limitations will be removed in the GA release.

Let me know your thoughts in the comment section below and thanks for reading!

Hocine

L’article SQL-Server 2025: Vector Indexes & Semantic Search Performance est apparu en premier sur dbi Blog.

In this article, we will explore the concept of data embeddings, a key concept for modern AI-driven applications and platforms. We will then examine the latest capabilities introduced in SQL Server 2025 (preview) and Azure SQL, focusing on their new support for vector data types. Finally, we will generate embeddings using an AI model and store them directly in our database, demonstrating how to integrate AI-powered semantic abstraction into your SQL workloads.

But First: What Exactly Are Data Embeddings?

Let’s start from the back. From a linguistic perspective, written text consists of syntax and semantics. While syntax refers to the structure of the text and the arrangement of words and letters, semantics refers to the actual meaning conveyed by the text. You can have text with a similar syntax but a different semantic and you can also have text with a similar or the same semantic but different syntax. For example:

• Sentence 1: Our customer satisfaction has increased.
• Sentence 2: The contentment of our clients is better than before.

While both sentences have basically the same meaning, they differ in structure and the way the words and letters are arranged.

In IT, we have different simple ways to search for syntax matches, such as exact string matching, wildcard searches or regular expressions (Regex) for more sophisticated syntax matches.

But when we are looking for semantic matches, simple programming functions that only evaluate and compare the arrangement of letters are not enough. In such cases, we need a human, or another form of intelligence, that can interpret those arranged letters and understand their meaning.

That’s exactly where AI comes into play. The AI model basically reads and understands the written text, then it generates a numerical representation for the semantic of that text which we call “embedding”.

When I first heard about embeddings, I asked myself: Okay, but what is the data embedded in?

The answer is that the data is embedded in a high-dimensional mathematical space, with the vector data representing its coordinates within that space. Since the semantics of embedded data are represented as coordinates in a mathematical space, we can calculate the distance between embeddings and use that to search for data with similar meaning.

If you want to learn more about the theory of vectors and embeddings, I can highly recommend the article by my colleague Amine Haloui – he explains the basic mathematical concepts in an understandable way, even if you’re not a mathematician.

Enough Theory for Now – Let’s Get Practical!

Lets take a look how we can generate data embeddings with the latest functions and features of SQL-Server 2025 and Azure SQL directly within our database through T-SQL.

For that I’m using the same sample database which we already used in the previous blog post. But in the meantime I created a new column in my “dbo.products” table and I inserted in that column the AI generated product description for each product. If you are wondering how I did that – you can read it here.

select p.product_id, p.product_name, p.Description, p.currency, p.price, c.category_name, b.brand_name, co.color_name, g.gender, s.season from dbo.products p
inner join dbo.category c on p.category_id = c.category_id
inner join dbo.brand b on p.brand_id = b.brand_id
inner join dbo.color co on p.color_id = co.color_id
inner join dbo.gender g on p.gender_id = g.gender_id
inner join dbo.season s on p.season_id = s.season_id

Deploy an embedding Model:

For generating embeddings for our product data we need first an AI model which is capable to do that. Therefore I go into my Azure OpenAI Resource and I’m searching in the Model catalog in the Azure Foundry Portal for embedding models (I show you exactly who I can go there and deploy resources in the previous blog). There are currently three embedding models available from OpenAI. I’m choosing for this blog post the model 3-small and I’m deploying it with a click on “text-embedding-3-small” -> “use this model”->”Deploy” :

Then I’ll find the model in the Azure AI Foundry Portal under the section “Deployments”:

When clicking on the model I’m able to see my models API endpoint and the access key:

Create a Database Scoped Credential:

Okay so far so good, let’s connect to our SQL-Server 2025 Instance where the ShopAI database is running on. To register the external model in our database and access it through the appropriate T-SQL functions, I first create a database-scoped credential. You can create the credential with a managed identity or with an API Key. I’m using the API Key which I copied from the Azure AI Foundry Portal. Note that the credential name must point to a path which is more generic than the request URL:

-- Create database scoped credential:
CREATE DATABASE SCOPED CREDENTIAL [https://shopai-blog.openai.azure.com/]
	WITH IDENTITY = 'HTTPEndpointHeaders', secret = '{"api-key":"YOUR-API-KEY"}';
GO

Register the External AI Model:

As far as the database scoped credential is created we can register the external model with the “Create External Model” command, which is currently available in SQL-Server 2025 Preview, in our database. You can find more information’s about this brand new command under the following link from Microsoft: https://learn.microsoft.com/en-us/sql/t-sql/statements/create-external-model-transact-sql?view=sql-server-ver17

-- Create EXTERNAL MODEL
CREATE EXTERNAL MODEL OpenAITextEmbedding3Small
AUTHORIZATION dbo
WITH (
      LOCATION = 'YOUR-ENDPOINT_URL',
      API_FORMAT = 'Azure OpenAI',
      MODEL_TYPE = EMBEDDINGS,
      MODEL = 'text-embedding-3-small',
      CREDENTIAL = [YOUR-CREDENTIAL],
      PARAMETERS = '{"Dimensions":1536}'
);

Test the Embedding Function

As far as we created the external model successfully we can generate the embeddings with the “AI_Generate_Embeddings” function. This function is currently available in SQL-Server 2025 Preview.

The function requires the text to be embedded and the name of a pre-created external model as arguments, with optional model-specific parameters that can be appended in JSON format. You can get more information’s about this brand new function under the following link from Microsoft: https://learn.microsoft.com/en-us/sql/t-sql/functions/ai-generate-embeddings-transact-sql?view=sql-server-ver17

Let’s test the registered model and the embedding function with the command below. As you can see, the result is a JSON array containing multiple numerical values:

Generate and Store Product Embeddings:

Having deployed the embedding model in Azure, registered it in our database, and successfully tested the embedding function, our next step is to generate embeddings for our products.

Therefore I add an additional column called “embedding” to our “dbo.products” table. For the column I’m using the vector data type which is currently available in Azure SQL and in SQL-Server 2025 preview. Note the number in the brackets of the datatype definition is representing the amount of dimensions which are used for the embedding. Who many dimensions you need is depending on the model you are using. The “text-embedding3-small” model from OpenAI is using 1536 dimensions per default:

ALTER TABLE dbo.products
ADD embedding vector(1536);

I now want to generate embeddings for all products in my ShopAI database and store them in the newly created column, taking the following product attributes into account when generating the embeddings:

• Product Name
• Product Description
• Product Price
• Product Season
• Product Gender

To accomplish this, I use the code below to generate the embeddings:

UPDATE p
SET p.embedding = AI_GENERATE_EMBEDDINGS(
    CONCAT(
        N'Product Name: ',            COALESCE(p.product_name, N'Unknown'),
        N' | Product Description: ',  COALESCE(p.[description], N'Unknown'),
        N' | Product Price (CHF): ',  COALESCE(CONVERT(NVARCHAR(32), p.price), N'Unknown'),
        N' | Product Season: ',
        CASE p.season_id
            WHEN 1 THEN N'Spring'
            WHEN 2 THEN N'Summer'
            WHEN 3 THEN N'Autumn'
            WHEN 4 THEN N'Winter'
            WHEN 5 THEN N'All Seasons'
            ELSE N'Unknown'
        END,
        N' | Product Gender: ',
        CASE p.gender_id
            WHEN 1 THEN N'Male'
            WHEN 2 THEN N'Female'
            WHEN 3 THEN N'Unisex'
            ELSE N'Unknown'
        END
    ) USE MODEL OpenAITextEmbedding3Small
)
FROM dbo.products AS p
WHERE p.embedding IS NULL;

The query ran for over four minutes and successfully generated embeddings for all products:

Test Semantic Similarity Functions:

So far so good, we were able to deploy an embedding model in Azure, we successfully created a credential for the access to the model, we registered the embedding model with the latest T-SQL command and we were able to generate embeddings for our products.

Let’s see how we can use now the embedding model and the embedded data for semantic search capabilities.

Therefore I’m using the “Vector_Distance” function which is available in SQL-Server 2025 preview and in Azure SQL. The function requires 3 arguments: The first is the metric you want to use for calculating the distance between two embeddings, and the other two are the vectors you want to compare.You can get more information’s about this brand new function under the following link from Microsoft: https://learn.microsoft.com/en-us/sql/t-sql/functions/vector-distance-transact-sql?view=sql-server-ver17

Okay, let’s see how we can use this function – It’s summer and I would like to go on summer vacation (again). Therefore I’m looking for some pants which I can wear during my summer holidays. I don’t like anything flashy, so I’d like the pants in black.

Let’s test with the code below if we can find a matching product for me:

DECLARE @SemanticSearchText Nvarchar(max) = 'Im looking for black pants for men which I can wear during my summer vacation.'

	
	DECLARE @qv VECTOR(1536) = AI_GENERATE_EMBEDDINGS(@SemanticSearchText USE MODEL OpenAITextEmbedding3Small);

	SELECT TOP(10) 
	  product_name, 
	  Description,
	  price,
	  s.season,
	  g.gender,
	  VECTOR_DISTANCE('cosine', @qv, embedding) AS distance 
	FROM dbo.products p
	  inner join dbo.season s on p.season_id = s.season_id
	  inner join dbo.gender g on p.gender_id = g.gender_id
ORDER BY   distance;

As you can see, the results are quite accurate. All of the products are pants, except for the one with the highest distance, which is a full swimsuit. Every product is black in color, and most are categorized for the summer season, except for two that are suited for all seasons:

As you can see by combining SQL Server 2025’s new vector capabilities with external embedding models, we can seamlessly integrate semantic understanding directly into our data workflows. This enables intelligent, context-aware queries that go far beyond simple keyword matching.

You can find all the code again on GitHub and test it by your own. Feel free to share your thoughts with me in the comment section and stay tuned for upcoming posts from my colleagues and me. 😉

Thanks for reading,
Hocine

L’article SQL-Server 2025: Generate Data Embeddings for Semantic Search est apparu en premier sur dbi Blog.

Providers of modern and future-oriented platforms and applications seem to be aware of this development and are integrating AI in a targeted manner to increase efficiency and improve the user experience.

With SQL Server 2025 being the most developer-oriented release in over a decade, Microsoft is clearly targeting the AI evolution making it easier than ever to integrate AI with your data.

In this article I will introduce you in two of the latest AI oriented features which are now available in SQL-Server 2025 preview and I will show you an example how you can interact with an external AI-model programmatically.

sp_invoke_external_rest_endpoint:

While the stored procedure sp_invoke_external_rest_endpoint was already available in Azure SQL Database and Managed Instance it’s now also available in  SQL-Server 2025 Preview and allows you to communicate with external REST services from On-Premise.

This is significant in terms of AI because AI-models which are hosted on Cloud Platforms or on Premise (for example with Ollama) are usually REST compatible. This stored procedure allows you so to interact with an external AI model directly and programmatically through T-SQL.

You can find more information about the stored procedure and the specific parameters on the following Link from Microsoft: https://learn.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sp-invoke-external-rest-endpoint-transact-sql?view=sql-server-ver17&tabs=request-headers

JSON Datatype:

In the previous version of SQL-Server JSON Data was stored in the varchar and nvarchar datatypes. With SQL-Server 2025 you can now store JSON data in a JSON datatype. The JSON datatype which is also available in Azure SQL Database and Azure SQL Managed Instance brings multiple advantages over working with JSON Data in nvarchar and varchar datatypes.

As the new JSON Datatype is compatible with all JSON functions no code change is necessary while benefiting from the following advantages:

• reads are faster because with the JSON datatype your JSON data is already parsed
• you can update also individual values without accessing the whole JSON data
• the JSON datatype is optimized for compression which makes the storage more efficient

In terms of AI this is significant because external AI-models are usually transferring data in the JSON format. With the new JSON datatype you can handle this data efficiently.

To get more detailed information’s about handling JSON data with T-SQL and about the new JSON datatype, you can access the following Link from Microsoft: https://learn.microsoft.com/en-us/sql/relational-databases/json/json-data-sql-server?view=sql-server-ver17

Hands On – Generating Product Descriptions using AI:

Enough theory for now! let’s get practical. For demonstration purposes, I’ve prepared a sample shop database for a clothing reseller running on SQL-Server 2025.

The database has some few tables which are containing product information’s:

With the following query you can see that we have 3000 products with different categories from different brands etc.

select p.product_id, p.product_name, p.currency, p.price, c.category_name, b.brand_name, co.color_name, g.gender, s.season 
from dbo.products p 
inner join dbo.category c on p.category_id = c.category_id 
inner join dbo.brand b on p.brand_id = b.brand_id 
inner join dbo.color co on p.color_id = co.color_id 
inner join dbo.gender g on p.gender_id = g.gender_id
inner join dbo.season s on p.season_id = s.season_id

What we don’t have is a product description for attracting potential buyers. This is something we will do now using AI. Therefore I need an AI model which I can integrate with my product data. I deploy this model in Azure.

Deploy an AI Model in Azure:

In the Azure Portal I’m looking therefore for Azure AI Foundry.

Then under AI Foundry I create a new resource of Azure OpenAI:

The deployment is pretty much straight forward and after the deployment is finished I access my newly created resource:

In my new Azure OpenAI resource I’m accessing now the Azure AI Foundry portal for deploying a new AI-model:

In the AI Foundry Portal I’m looking under the Model catalog for chat completion models and I select the gpt-4o model which is the “allrounder” AI-model for chat completion tasks from OpenAI(It’s in fact currently the model you are using with ChatGPT by default if you don’t choose anything else specifically):

After clicking on the gpt-4o model, I clik on “Use this model” and finally on “deploy” for deploying the model:

As far as I deployed the model successfully I’m able to find it in the Azure AI Foundry Portal under “Deployments”:

After clicking on the newly deployed model I can also find my https URL and API key for accessing the model:

Interacting with the AI Model using T-SQL:

As the model is now successfully deployed we are ready to interact with it using T-SQL. Therefore I wrote a small stored procedure around the stored procedure sp_invoke_external_rest_endpoint which is doing the following stuff:

It takes the Product ID, API Key, API Endpoint URL and the desired description language as input parameters:

It selects necessary product data for the provided Product ID from the database and stores it as a single string:

It generates a prompt for the chat completion API and dynamically interpolates the selected product data into that prompt:

Finally it invokes the external AI model using the stored procedure sp_invoke_external_rest_endpoint with the generated prompt:

With the code below I’m then executing the stored procedure above for a specific product in my database and I’m extracting the product description from the AI models JSON response:

As a random example I have this swim shorts in the color magenta in my Shop database with the product ID 2354:

I’m now able to generate a product description using the gpt-4o model hosted in Azure for this specific product:

You can see here the full product description which was returned by the gpt-4o model:

The description is pretty good isn’t it? If magenta suited me, I would definitely buy one

The GPT-4o model is also quite a language expert. For example, you can even generate your product descriptions in Chinese.

In case that I have Chinese speaking blog readers or if someone wants to translate it, here is again the full description:

If you want to test it by your own you can find the whole code and a backup of the ShopAI database on GitHub: https://github.com/HocineMechara/SQL2025-AI-Product-Description-Blog

Of course, this is just a simple example. You can do much more. For instance, you could provide additional context to the chat completion model, such as the user’s recent orders or behavioral data, to generate personalized product descriptions tailored to individual customers.

Feel free to share your thoughts in the comments, and stay tuned for upcoming posts from my colleagues and me.

Thanks for reading,
Hocine

L’article SQL Server 2025: Where Data Meets Intelligence est apparu en premier sur dbi Blog.

The sessions and workshops on the event mainly focused on the evolution of AI and a lot about Business Intelligence and Data Engineering with a big focus on Microsoft Fabric the unifying data platform from Microsoft. The choice of topics reflects the direction in which I believe the industry is heading, and I took the opportunity to gain valuable insights from renowned experts.

On the first day, I attended a one-day workshop on the latest AI functionalities in SQL Server and Azure SQL, focusing on how these features support the integration of external AI models with your data, enabling the development of context- and data-aware AI assistants for your application’s users based on the RAG (Retrieval-Augmented Generation) pattern. It was very interesting, the workshop was delivered in a high quality and it was even my personal highlight of the event.

On the second day I joined again a one-day workshop about Microsoft Fabric. I was very curious about Microsoft Fabric because I heard a lot of advantages about this end to end SaaS Data Platform and I was happy to learn more about it. The workshop covered a lot of topics regarding Microsoft Fabric and at the end of the day I had a good feeling of understanding the concept and the core elements about Microsoft Fabric.

During the break I enjoyed a fancy coffee served at the Microsoft booth

On the last day I attended again a one-day workshop about Microsoft Fabric but with more focus on the administration of a Fabric Tenant including workspace management, security, Git Integration etc. The workshop was again delivered in a good quality and I really enjoyed to attend. The Kahoot Quiz at the end of the workshop confirmed my Impression that I’m on track of understanding this platform quite well.

The event was awesome, I learned a lot about the latest technologies and I hope that I will be able to apply the gained knowledge in upcoming projects. I can highly recommend this event to every data professional working with Microsoft technologies!

L’article Exploring the Future of Data at SQLBits 2025 in London est apparu en premier sur dbi Blog.

To ensure persistence across restarts, trace flags need to be set as startup parameters. Traditionally, this can be done manually through two main avenues: using the SQL Server Configuration Manager or editing the Windows Registry directly. However, both of these approaches require manual interaction and are not ideal for automated deployments, large-scale environments or automated deployments.

Unfortunately, SQL Server doesn’t provide a built-in command-line tool or T-SQL syntax to set trace flags as startup parameters programmatically. This gap leaves many DBAs and system engineers either scripting complex registry edits themselves or relying on manual configurations.

That’s exactly the problem I set out to solve. I developed a PowerShell function that allows you to set SQL Server trace flags as startup parameters in a programmatical way and I’m using this function already at one of my customers to set Trace flags within an automated deployment process. This function not only configures the registry settings required for each SQL Server instance on a server, but it also offers optional functionality to restart the SQL Server service—ensuring that your changes take effect immediately. Even better, it includes logic to detect which trace flags are already in place and avoids redundant updates.

In this blog post, I’ll walk you through how the function works, how to use it in your own environment, and how it can fit into your broader infrastructure automation strategy. Whether you manage a single SQL Server or dozens across a large environment, this solution aims to simplify your workflow and reduce the risk of human error.

Let’s take a look at how to set the Trace flag programmatically with the PowerShell Function:

I have the function stored in a ps1 file within my visual studio project directory.

To execute the function and pass the appropriate input parameters to the function, I create a second .ps1 file in the same directory.

In this file I add the following values in variables:

$Trace flags – The trace flags I would like to set for the particular instances

$Restart – This defines if the SQL-Server Service should be restarted after setting the trace flags (Y = restart, N = no restart)

$ServerName – This defines the Server on which the trace flags should be set as a startup parameter for every instance running on it

$Cred –This is the credential which is used to access the remote Server

Then I import the function as a module and execute the function with the values stored in the variables as input parameters.

After saving the file I execute it from the terminal. You can see that the Trace flags have been successfully set.

When we take a look in the registry on the particular server we can see, that the Trace flags have been added.

We can see the same result when taking a look on the startup parameters from the SQL Server Configuration Manager.

Let’s take a look from the SQL Server Management Studio. With the DBCC TRACESTATUS() function. You can see, that no trace flags are currently active.

This is because the trace flags are set as startup parameters and will become active on the next service start.

After restarting the SQL Server service, we can see that the trace flags are now active.

In a running production environment, you can also enable the trace flags using the DBCC TRACEON() command with a global scope (-1) to avoid service interruption. This allows the trace flags to take effect immediately without restarting the SQL Server instance. Since the script also adds them as startup parameters in the registry, the trace flags will persist after the next restart.

DBCC TRACEON (2371, -1);
GO
DBCC TRACEON (3226, -1);
GO

The function is as well “intelligent” enough to see which trace flags are already in place and only sets the trace flags which are missing.

When I execute the function again with the same trace flags, you can see, that the functions tells you that the trace flags are already in place.

The function can also trigger a restart of the SQL-Server service to ensure that the trace flags become active immediately. Let consider therefore, that we want to set additionally the trace flag 1211. I change as well the $Restart variable to ‘Y’ to trigger a service restart.

After saving the file and executing it again from the terminal you can see that the trace flag 1211 has been set and that the instance has been restarted.

As the function triggered a restart of the instance, you can now see from the SQL Server Management Studio that the trace flag has become already active.

I hope this post was interesting for you Let me know your thoughts in the comment section below.

I’ve uploaded the PowerShell function to GitHub. You can access it under this link: https://github.com/HocineMechara/SetSQLServerTrace flags.git

L’article Set SQL Server Trace Flags Automatically and Smoothly est apparu en premier sur dbi Blog.

Initial Setup:

For this blog I’m using a ubuntu server as a automation server where I’m running Terraform. You can install Terraform on different operating systems. For instructions how to install Terraform check out this link from HashiCorp.

Starting with the hands on part I’m creating a new dedicated directory for my new Terraform project:

Within this new directory I’m creating the following files which will hold my configuration code:

• main.tf
• providers.tf
• variables.tf
• outputs.tf

Installing the Azure CLI:

For the authentication with Azure I’m using the Azure CLI command line tool. You can Install the Azure CLI on Ubuntu with one command which curls a script, provided by Microsoft, from the internet and executes it on your system:

curl -sL https://aka.ms/InstallAzureCLIDeb | sudo bash

To get more information’s about how to install the Azure CLI on your system, checkout this link from Microsoft.

As far as the installation is successfully done, you can verify it with the following command:

az –version

Then use the following command for connecting to Azure:

az login

This command will open a browser window where you can sign in to Azure:

After you successfully authenticated yourself to Azure, you can check your available subscriptions with the following command:

az account list

Initialize Terraform:

As the Azure CLI is now installed on the system and we are successfully authenticated to Azure, we can now start with the configuration of Terraform and the required provider for interacting with the Azure cloud platform.

Therefore I add the code block below into the providers.tf file which will tell terraform to install and initialize the azurerm provider with the specific version 4.10.0, which is the latest at the moment:

To configure the azurerm provider, I add the provider code block below additionally into the providers.tf file.

You can find your subscription ID in the output from the “az account list” command above.

After inserting those code blocks into the providers.tf file, we can install the defined azurerm provider and initialize Terraform by running the below command in our project directory:

terraform init

Terraform Workspaces:

As Terraform is now successfully initialized and the required provider is installed, we can start with the development of our infrastructure code.

But before doing so I would like to target the concept of workspaces in Terraform. Workspaces enables you to use the same configuration code for multiple environments through separate state files. You can imagine workspaces as a separated deployment environment and you terraform code as a independent plan or image of your infrastructure. As an example, imagine you added a new virtual machine to your terraform code and deployed it in production. If you now want to have the same virtual machine for test purposes, you just have to switch into your test workspace and run the terraform code again. You will have the exact same virtual machine within a few minutes!

To check the workspaces you have in your Terraform project, use the following command:

terraform workspace list

As you can see we just have the default workspace in our new Terraform project. I want to deploy my infrastructure in this hands on blog post for multiple environments, therefore I will create some new workspaces. Lets assume we have a development, test and production stage for our infrastructure. I will create therefore the workspaces accordingly with the commands below:

terraform workspace new development

terraform workspace new test

terraform workspace new production

After executing these commands, we can now check again our available workspaces in our terraform project:

Note that terraform will let you know your current workspace through the “*” symbol behind the particular workspace. We want to deploy our infrastructure for development first. So I will switch back into the development workspace with the following command:

terraform workspace select development

Create an Azure Resource Group:

As the workspaces are now successfully created, we can start with our configuration code.

First of all I go into the variables.tf file and add the variable code block below to that file:

I will use this “env” variable for the suffix or prefix of resource names, which I will deploy, to simple recognize to which environment these resources belong.

Next I will create a resource group in Azure. Therefore I add the code block below to the main.tf file:

As you can see I set the name of the resource group dynamically with the prefix “RG_” and the value for the current workspace in the variable “env”, which I’ve defined before in the variables.tf file. The variable “terraform.workspace” is a default variable which refers to the current workspace.

To check which resource terraform would create in case we would apply the current configuration code, we can run the following command:

terraform plan

We can see that terraform would create a new resource group with the name “RG_DEV”.

Create a Virtual Network and Subnets:

Next I will create a virtual network. Therefore I add the variable code block below to the variables.tf file. This variable defines for each environment stage a own address space:

I add now the code block below to the main.tf file to create a virtual network:

As you can see I’m referencing here as well to the “env” variable for dynamically setting the suffix of the network name and as well to the new “cidr” variable to set the address space of the virtual network.

Next I will create some subnets within the virtual network. I want to create 4 subnets in total:

• A front tier subnet
• A middle tier subnet
• A backend tier subnet
• A bastion subnet for the administration

Therefore I add the variable below to my variables.tf file, which defines for each environment stage and subnet an address space:

Next I will add for each subnet a new resource block to the main.tf file:

Note that I enabled in the backend tier subnet the option “private_endpoint_network_policies”. This is a option which enforces the network security groups to take effect on the private endpoints in the particular subnet. Checkout this link from Microsoft for more information’s about this option.

Create an Azure SQL Database:

Next I will create an Azure SQL Server. Therefore I add the variable below to my variables.tf file. This variable is supposed to hold the admin password of the Azure SQL Server. I set the sensitivity option for this variable which will prevent the password to be exposed in the terminal output or in the Terraform logs:

I did also not set any value in the configuration files, instead I will set the variable value as a environment variable before applying the configuration.

Next I add the code block below to my main.tf file:

As you can see I referenced the “sqlserver_password” variable to set the password for the “sqladmin” user. I also disabled the public network access to prevent database access over the public endpoint of the server. I will create instead a private endpoint later on.

Next I will create the Azure SQL Database. Therefore I add the variable below to my variables.tf file:

The thought behind this variable is, that we have different requirements for the different stages. The general purpose SKU is sufficient for the non-productive databases but for the productive one we want the business critical service tier. As well as we want to have 30 days of point in time recovery for our productive data while 7 days is sufficient for non-productive and we want to store our productive database backups on geo-zone redundant storage while zone redundant storage is sufficient for the non-productive databases.

Then I add the resource block below into my main.tf file:

As you can see I’m referencing to my “database_settings” variable to set the configuration options dynamically.

Create a DNS Zone and a Private Endpoint:

For name resolution I will next create a private DNS zone. For that I add the resource block below to my main.tf file:

To associate this private DNS zone now with my virtual network, I will next create a virtual network link. Therefore I add the resource block below to my main.tf file:

To be able to securely connect to my azure sql database I will now create a private endpoint in my backend subnet. Therefore I add the resource block below to my main.tf file:

With this configuration code, I create a private endpoint with the name of the Azure SQL Server and the suffix “-endpoint”. Through the option “subnet_id” I place this endpoint in the backend subnet with a private service connection to the Azure SQL Server. I also associate the endpoint to the private DNS zone, which I’ve created just before, for name resolution.

Create an Azure Bastion:

Lets now continue and create an azure bastion host for the administration of our environment. Therefore I first create a public IP address through adding the resource block below to my main.tf file:

Next I create the bastion host itself. For that I add the code block below to my main.tf file:

Create a Virtual Machine:

Now I will add a virtual machine to my middle tier subnet. Therefore I need to create first a network interface for that virtual machine. The resource block below will create the needed network interface:

As the virtual machine, which I intend to create, needs an admin password like the azure sql server, I will create an additional password variable. Therefore I add the code block below to my variables.tf file:

To create the virtual machine itself, I add the resource block below to my main.tf file:

Create Network Security Groups and Rules:

Next I want to secure my subnets. Therefore I create for my front tier, middle tier and backend tier subnet a network security group by adding the resource blocks below to my main.tf file:

Next I create for each network security group particular rules.

Starting with the front tier subnet I want to block all Inbound traffic except traffic over https. Therefore I add the two resource blocks below to my main.tf file:

Continuing with the middle tier subnet I want to block all inbound traffic but allow http traffic only from the front tier subnet and allow rdp traffic only from the bastion subnet. Therefore I add the three resource blocks below to my main.tf file:

Last but not least I want to block all Inbound traffic to my backend tier subnet except traffic to the sql-server port from the middle tier subnet. In addition I want to block explicitly the internet access from this subnet.

You are questioning why I’m explicitly block internet access from this subnet while I haven’t any public IP address or NAT gateway for this subnet? That’s because Microsoft provides access to the internet through a default outbound IP address in case no explicit way is defined. That’s a feature which will be deprecated on the 30^th September 2025. To get more information’s about this feature check out this link from Microsoft.

To create the rules for the backend tier subnet I add the three resource blocks below to my main.tf file:

Define Output Variables:

I will stop with the creation of resources for this blog post and will show you finally how you can define outputs. For example let’s assume we want to have the name of the Azure SQL Server and the IP address of the virtual machine extracted after the deployment. Therefore I add the two output variables below to the outputs.tf file:

Outputs are especially useful when you need to pass up information’s from the deployment to a higher context. For example when you are working with modules in terraform and you want to pass information’s from a child module to a parent module. In our case the outputs will just be printed out to the command line after the deployment.

Apply the Configuration Code:

As I am now done with the definition of the configuration code for this blog post, I will plan and apply my configuration for each stage. Before doing so, I need to first set a value for my password variables. On Ubuntu this can be done with this command:

export TF_VAR_sqlserver_password=”your password”

export TF_VAR_vm_password=”your password”

After I’ve set the variables, I run the terraform plan command and we can see that terraform would create 29 resources:

This seems to be good for my so I run the terraform apply command to deploy my infrastructure:

terraform apply

After some minutes of patience terraform applied the configuration code successfully:

Check the Infrastructure in the Azure Portal:

When I’m signing in to the Azure portal I can see my development resource group with all the resources inside:

I want to have my test and production resources as well so I switch the terraform workspace to test and production and run in both workspaces again the terraform apply command.

After some additional minutes of patience we can see in the Azure portal that we have now all resources for each environment stage:

Lets now compare the settings from the productive database with the development database and we can see that the SKU for the productive one is business critical while the SKU for the non-productive one is general purpose:

The Backup storage has also been set according to the “database_settings” variable:

We can see the same for the point in time recovery option:

We can see that our subnets are also all in place with the corresponding address space and network security group associated:

Lets check the private endpoint of the Azure SQL Server. We can see that we have a private IP address within our backend subnet which is linked to the Azure SQL Server:

Lets connect to the virtual machine and try a name resolution. You can see that we were able to successfully resolve the FQDN:

After installing SQL-Server management studio on the virtual machine, we can also connect to the Azure SQL Server through the FQDN of the private endpoint:

Delete the Deployed Resources:

For now preventing getting a high bill for something I didn’t use, I will now delete all resources which I’ve created with Terraform. This is very simple, and can be done through running the terraform destroy command in each workspace:

terraform destroy

I hope you got some interesting examples and ideas about Terraform and Azure! Feel free to share your questions and feelings about Terraform and Azure with me in the comment section below.

PS: I’ve uploaded the configuration code used in this blog post to a GitHub repository to make it easier for you to reproduce the steps and examples. You can find it here.

L’article Automate your Deployments in Azure with Terraform! est apparu en premier sur dbi Blog.

But what is now a head blocker?

A head blocker is a transaction that is either very slow or never commits, holding locks on database resources. Other transactions that must access the resources locked by the head blocker are also holding locks while waiting for those resources.

On the next level, there are more transactions that need access to resources locked by the transactions blocked by the head blocker, and they too are holding locks. This process continues on multiple levels, creating a “lock chain” where all the transactions are waiting for the first transaction (the head blocker) to commit or roll back.

For the non-technical blog reader, let me give you an example from a daily life situation:

You are in the supermarket and you see a long queue behind the checkout. At the front of the queue you can see person A who is talking with the cashier about the weather, the next neighborhood event and about the cat of the neighbor. This person is the head blocker. Behind that person is person B  and person C waiting. This is the beginning of the lock chain and the checkout is the database resource on which the head blocker is holding a lock.

To better understand the complexity of the lock mechanism in relational database systems with this metaphor imagine that only one person is allowed to have a specific item in their shopping cart at any given time in the supermarket.

Person C is waiting for person A at the checkout and has a liter of milk in their shopping cart. Person D, who already has bread and butter in their shopping cart, but wants some milk too, must wait until person C can pay and leave the supermarket. Person E and F, who also already have some items in their shopping cart but still have butter or bread on their shopping list, must wait too. The whole process continues until everyone in the supermarket is waiting for person A to complete the story about the neighbor’s cat.

In the case of my customer, the IT-staff there terminated the head blocking transaction manually as far as they recognized it.

The major problem on this approach was, that the IT-staff remarked the problem through user feedback. So way too late.

Therefore I implemented a custom developed alert solution for the case when blocking is increasing within the applications database. This enabled the IT-staff to terminate the head blocking transaction before the application users were disturbed.

How to determine blocking in a database?

SQL-Server offers some very useful dynamic management views (DMV) to query information’s about blocking. For example the DMV  “sys.dm_exec_requests”. When you query this DMV and you are interested in blocking, the most interesting column is the “blocking_session_id” column.  This column shows you which session is currently blocking the particular request. If the request isn’t blocked, there will be a “0”.

There are also other pragmatic ways to gather information about currently running processes and their blocking. One very user-friendly method that provides a wealth of useful information is the stored procedure sp_whoisactive, developed by Adam Mechanic. This stored procedure displays currently running processes in SQL Server in a user-friendly manner and can be managed through multiple input parameters. It also returns a blocking_session_id column and many other useful details, such as the SQL text, the number of reads and writes, CPU time, and more. The stored procedure is not available by default in SQL Server but can be downloaded and installed from GitHub. 

Another valuable solution is the stored procedure sp_HumanEventsBlockViewer, created by Erik Darling. This procedure is used in conjunction with an extended event session, which collects data from the Blocked Process Report. The stored procedure reads from the extended event session and presents the information in a very useful format, including valuable details such as the SQL text, the isolation level of the transactions, the wait time, and more.

I used th DMV “sys.dm_exec_requests” in the stored procedure that I developed to monitor blocking in the customer’s database.

Please note that I’m just sharing some key snippets of the stored procedure and not the entire procedure, as sharing the whole one would go beyond the planed scope of this blog post.

The stored procedure queries first of all the DMV with the “count” aggregation function to get the total number of blocked requests:

After that the stored procedure checks if the amount of blocked requests exceeds the defined sensitivity threshold:

If this is true, the stored procedure starts with the collection of the information’s which we were interested in. The first information is the session that is holding the most locks in the database. Therefore I wrote the query below which is storing the particular session ID in a variable:

After that, the stored procedure additionally gathers the number of blocked requests by this session and stores it in a second variable:

After that I used the session ID from the session, which is blocking the most requests, as a starting point to loop the lock chain up through  the DMV:

After that I formatted everything in HTML and sent the information’s through the database mail. This resulted in the mail below which warned the recipients about the exceeding of the blocking threshold and provided some valuable information’s:

Summary:

This blog post presents an approach to monitor blocking within a SQL-Server database. Locking is an important mechanism in SQL-Server and other relational database systems to ensure transactional isolation and it is usual that locking leads to blocking in an acceptable extent. However, extensive blocking can slow down the performance, which is considered a problem. There are multiple of potential root causes of blocking problems, including:

• Poor query performance, leading to long running transactions
• Lock escalation
• High concurrency on particular database resources
• Bad transaction design
• High transaction isolation level

If you are facing similar problems or if you have any questions don’t hesitate to share it in the comment section!

L’article Understanding Head Blockers in SQL-Server est apparu en premier sur dbi Blog.

A couple of weeks ago I had a customer who was interested in monitoring the duration of some of his SQL-Agent jobs. The jobs were running in a data warehouse environment and were executing some ETL processes for loading data. The goal was to get informed when one of these specific jobs were running significantly longer than usual. Therefore I wrote a short stored procedure and a script which I would like to show you in this blog post!

First of all, I would like to start with explaining the parameter’s of the stored procedure to get a better understanding of the logic:

Input parameter’s:

We have the following input parameter’s for influencing the behavior of the stored procedure:

@SensitivityPercentage: This “float” parameter defines the percentage increase of the last job runtime compared to the calculated average value, which must be exceeded to set the @ThresholdExceeded output variable as true. I set the default value for this Input parameter to “30%” or “0.3“ in decimal, but the value can be overwritten to a less or more aggressive behavior when executing the stored procedure.

@SensivityTotalMinutes: This “integer” parameter defines the increase in minutes of the last job runtime compared to the calculated average value, which must be exceeded to set the @ThresholdExceeded output variable as true. The default value in the stored procedure is 20 minutes, but it can be changed here as well!

Note: both values provided in the sensitivity variables must be exceeded to set the @ThresholdExceeded variable as true. I implemented this logic, for not getting notified when a job is increasing from 1 minute to 2 minutes – the increase would be 100% but as it’s only 1 minute I don’t care😉

@granularity: This “integer” parameter defines how many of the latest entries of the job history should be used to calculate a average value for comparing the last run duration. I set this with a default value of 5, but here as well you can change it.

Note: If in the job history are less than 5 entries, the stored procedure takes automatically the amount of entries which are available to calculate a average value.

@JobId -> This is quite obvious: The ID of the job which should be checked.

Output parameter’s:

To get some interesting values out of the stored procedure, I defined the following output parameters:

@AverageJobRunDuration: This is the average job run duration in minutes.

@RunDurationLastExecution: This is the duration of the last execution in minutes.

@Factor: This is the factor of the duration from the last execution compared to the calculated average value.

@IncreasionPercentageString: This is the increase or decrease of the last duration compared to the average value in a percentage value.

@IncreasionTotalMinutes: This is the increase or decrease of the last duration compared to the average value in minutes.

@OutputMessage: This is a generated output message.

@ThresholdExceeded: This defines if the threshold is exceeded based on the above sensitivity values.

The stored procedure:

See below the stored procedure:

CREATE PROCEDURE [dbo].[dbi_jobruntimeinfo]
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
--Parameters
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
(

--Input
@SensitivityPercentage float = 0.3,
@SensivityTotalMinutes int = 20,
@granularity int = 5,
@JobId uniqueidentifier,

--Output
@AverageJobRunDuration float OUTPUT,
@RunDurationLastExecution float OUTPUT,
@Factor float OUTPUT,
@IncreasionPercentageString NVARCHAR(50) OUTPUT,
@IncreasionTotalMinutes int OUTPUT,
@OutputMessage NVARCHAR(max) OUTPUT,
@ThresholdExceeded BIT OUTPUT

)

AS

Begin

   SET NOCOUNT ON;

------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
--Gather average runtime information
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
		declare @IncreasionPercentage float
       --@StepCount selects how many stps a specific Job has
       declare @StepCount Int
       Set @StepCount = (select count(*) from msdb.dbo.sysjobsteps where job_id = @JobId)

       --@RowCount dynamically sets how many rows of informations must be queried from job history --> its calculated between granularity and the amount of job steps for a specific job
       declare @RowCount Int
       Set @RowCount = @granularity * @StepCount

	   declare @TotalAvailableRows int
	   set @TotalAvailableRows = (
	   select count(*)
	   From msdb.dbo.sysjobs j 
	   INNER JOIN msdb.dbo.sysjobhistory h 
	   ON j.job_id = h.job_id 
	   where j.enabled = 1  --Only Enabled Job
	   and j.job_id = @JobId
	   and h.step_id != 0)

	   if @TotalAvailableRows <= @RowCount
		Begin 
			if @TotalAvailableRows <= @StepCount
				Begin
				Declare @MessageReturn NVARCHAR(max)
				Set @MessageReturn= 'Not enough History Data for Job with ID: ' +cast(@JobId as nvarchar(50))+ ' There is only: ' + cast((@TotalAvailableRows/@StepCount) as nvarchar (1)) + ' Runtime entrie in the history.'
				Print @MessageReturn
				set @AverageJobRunDuration = NULL
				set @RunDurationLastExecution = NULL
				set @Factor = NULL
				set @IncreasionPercentageString = NULL
				set @IncreasionTotalMinutes = NULL
				set @OutputMessage = @MessageReturn
				set @ThresholdExceeded = NULL
				Return
				End

			Set @RowCount = @TotalAvailableRows
			set @granularity = (@RowCount - @StepCount) / @StepCount
		End
			else
				Begin
					set @RowCount = @RowCount + @StepCount
				End
			print cast(@RowCount as NVARCHAR(max)) + ' Rowcount'
			print cast(@granularity as nvarchar(max)) + ' Granularity'

       --@SumRunDuration is for summing the total run Duration of all job executions defined in @granularity
       declare @SumRunDuration int

       Set @SumRunDuration = (Select SUM(RunDurationMinutes) from
       (select Top (@RowCount) j.name as 'JobName', h.step_id as 'StepID',
       msdb.dbo.agent_datetime(run_date, run_time) as 'RunDateTime',
       ((run_duration/10000*3600 + (run_duration/100)%100*60 + run_duration%100 + 31 ) / 60)
                     as 'RunDurationMinutes'
       From msdb.dbo.sysjobs j 
       INNER JOIN msdb.dbo.sysjobhistory h 
       ON j.job_id = h.job_id 
       where j.enabled = 1  --Only Enabled Job
       and j.job_id = @JobId
       and h.step_id != 0
       Order by run_date desc, run_time desc) SubSelect)

----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
--Gather last runtime information
----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

       declare @RowCountLastExecution int
       set @RowCountLastExecution = 1 * @StepCount

       set @RunDurationLastExecution = (Select SUM(RunDurationMinutes) from
       (select Top (@RowCountLastExecution) j.name as 'JobName', h.step_id as 'StepID',
       msdb.dbo.agent_datetime(run_date, run_time) as 'RunDateTime',
       ((run_duration/10000*3600 + (run_duration/100)%100*60 + run_duration%100 + 31 ) / 60)
                     as 'RunDurationMinutes'
       From msdb.dbo.sysjobs j 
       INNER JOIN msdb.dbo.sysjobhistory h 
       ON j.job_id = h.job_id 
       where j.enabled = 1  --Only Enabled Job
       and j.job_id = @JobId
       and h.step_id != 0
       Order by run_date desc, run_time desc) SubSelect)

       --@AverageJobRunDuration calculates the avarage runtime for a single job execution. Calculateion is made through @SumRunDuration and the @granularity
       set @AverageJobRunDuration = (@SumRunDuration - @RunDurationLastExecution) / @granularity
----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
--Calculate Factor
----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
       
       Begin try
              set @Factor = (1/@AverageJobRunDuration)*@RunDurationLastExecution
       End try
       Begin catch
              set @Factor = NULL
       End catch

----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
--Check if sensitivity threshold is exceeded
----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

       if @Factor != 0 and @Factor !< 0 and @Factor Is Not NULL
       Begin
              set @IncreasionPercentage = @Factor -1
              set @IncreasionTotalMinutes = @RunDurationLastExecution - @AverageJobRunDuration

				if @IncreasionPercentage > 0
				Begin
					set @IncreasionPercentageString = '+' + convert(nvarchar(max), @IncreasionPercentage*100) + '%'
				End
					Else
					Begin
					set @IncreasionPercentageString = convert(nvarchar(max), @IncreasionPercentage*100) + '%'
					End

       End 
              Else 
              Begin
              set @IncreasionPercentage = NULL
			  set @IncreasionPercentageString = NULL
              set @IncreasionTotalMinutes = NULL
              End

       If @IncreasionPercentage Is Not Null and @IncreasionTotalMinutes is not null and @IncreasionPercentage >= @SensitivityPercentage and @IncreasionTotalMinutes >= @SensivityTotalMinutes
       Begin
              Set @OutputMessage = 'Job with ID: ' + cast(@JobId as nvarchar(200)) + ' has exceed the defined thresholds. ' + 'The duration has increased by factor: ' +  cast(@Factor as nvarchar(200)) + ' Which is in total ' + cast(@IncreasionTotalMinutes as nvarchar(200)) + ' minutes.'
              Set @ThresholdExceeded = 1
       End
       Else
              Begin
              Set @OutputMessage = 'Job with ID: ' + cast(@JobId as nvarchar(200)) + ' has not exceeded the defined threshold'
              Set @ThresholdExceeded = 0
              End

End
GO

Execution Script:

In case of my customer I implemented a daily running job which is executing the stored procedure through an execution script. In this case a daily schedule was appropriate, as the ETL jobs were also running on a daily base.

In the script below, you can put every job name which should be monitored in the @Jobs variable and divide the names by semicolons. The STRING_SPLIT function will separate the string by semicolons and load the cursor with the job names. Note: that this functions is available from compatibility level 130 and above.

After the cursor is loaded with each job, the script will execute the stored procedure for each of them. If the threshold is exceeded for any of the provided jobs, the execution script will use SQL-Server mail to inform. To get informed you must put in the appropriate mail profile and recipients mail addresses in the @profile_name and @recipients input parameter!

See below the execution script:

declare @Jobs NVARCHAR(max)
Set @Jobs = ''

Declare @Job_Id uniqueidentifier
Declare @JobName Nvarchar(max)

--Load Jobs i cursor
declare jobs_cursor cursor
       for select value from STRING_SPLIT(@Jobs, ';')

open jobs_cursor
fetch next from jobs_cursor into @JobName

While @@FETCH_STATUS = 0
Begin

       --set JobId from Jobname
       set @Job_Id = (select j.job_id from msdb.dbo.sysjobs j where j.name = @JobName)

       --Exec SP
       declare @AverageJobRunDurationOut float
       declare @RunDurationLastExecutionOut int
       declare @FactorOut float
	   declare @IncreasionPercentageStringOut NVARCHAR(50)
       declare @IncreasionTotalMinutesOut int
       declare @OutputMessageOut NVARCHAR(max)
       declare @ThresholdExceededOut BIT

       exec dbo.dbi_jobruntimeinfo @SensivityTotalMinutes = 1,
       @JobId = @Job_Id,
       @AverageJobRunDuration = @AverageJobRunDurationOut Output,
       @RunDurationLastExecution = @RunDurationLastExecutionOut Output,
       @Factor = @FactorOut Output,
       @IncreasionTotalMinutes = @IncreasionTotalMinutesOut Output,
       @OutputMessage = @OutputMessageOut Output,
       @ThresholdExceeded = @ThresholdExceededOut Output,
	   @IncreasionPercentageString = @IncreasionPercentageStringOut Output;

       Select 
	   @JobName as 'Job',
	   @AverageJobRunDurationOut as 'AverageDuration',
	   @RunDurationLastExecutionOut as 'DurationLastExecution',
	   @IncreasionPercentageStringOut as 'IncreasionInPercent',
	   @IncreasionTotalMinutesOut as 'IncreasionMinutes',
       @ThresholdExceededOut as 'Threshold exceeded',
	   @FactorOut as 'Factor',
	   @OutputMessageOut as 'Message'

	   

	   if @ThresholdExceededOut = 1
	   Begin

		declare @bodycontent nvarchar(max)
		set @bodycontent = 'Job Name = '+@JobName+'; Average duration in minutes = '+cast(@AverageJobRunDurationOut as nvarchar(max))+'; Duration of last execution in minutes = '
		+cast(@RunDurationLastExecutionOut as nvarchar(max))+'; Slow down in percent = '+
		@IncreasionPercentageStringOut+'; Slow down in minutes = '+cast(@IncreasionTotalMinutesOut as nvarchar(max))
		
		declare @subjectcontent nvarchar(100)
		set @subjectcontent = 'SQL Agent Job: '+@JobName+' has slowed down'

		exec msdb.dbo.sp_send_dbmail
			@profile_name = '',
			@recipients  = '',
			@subject = @subjectcontent,
			@body = @bodycontent
       End

       fetch next from jobs_cursor into @JobName

End
CLOSE jobs_cursor;
DEALLOCATE jobs_cursor;

Let’s see how it works!

For testing I have two jobs as shown below:

The only thing which these jobs are actually doing is waiting:

The job Test_dbi_jobruntimeinfo has one step and the job Test_dbi_jobruntimeinfo_2 has two steps:

For demonstration purpose I made sure, that the history for both jobs is empty:

Let’s start and see how the stored procedure is going to behave when no data is in the history. Therefore I’m putting the name of both jobs in the @Jobs variable of my execution script:

In this demonstration I’m also selecting the output values from the stored procedure for showing the returned values:

I’m now executing the script and these are the values which are returned:

We can see that every value is “NULL” and the message says, that there is no history data available for the jobs. The stored procedure is even telling us the amount of available history data which is 0.

Let’s execute the jobs to generate a first entry in the history. Note: that each job step is running 35 second which would be rounded by the stored procedure to 1 minute. So the stored procedure will consider the job Test_dbi_jobruntimeinfo with one step as running one minute while the job Test_dbi_jobruntimeinfo_2 would be considered by the stored procedure as running two minutes.

The jobs are executed for the first time:

Now let’s execute again the script and see if we get any values:

We can see, that we still didn’t get any values. As we have only one entry in the history we obviously can’t compare the last run duration with the previous. But the message is now telling us, that we have “only 1” entry in the history.

I’m now executing both jobs again and after that the script and we can see from the script the following data:

We can see, that we have for the first time real data. As mentioned previously: In case that there is not enough history data to calculate the average according to the @granularity input parameter (which is 5 per default), the stored procedure is just taking the amount of history data which is available. So in this case were we have 2x entries in the history, the stored procedure is just taking the first duration as the average and compares the second execution to it.

I’m now executing the jobs again but now I’m changing the waiting duration within the job steps. For the first job Test_dbi_jobruntimeinfo, with only one step, I’m changing the wait duration to 1 minute and 35 seconds which will be considered by the stored procedure as 2 minutes. So we can expect for this job an increase of 100% returned by the stored procedure. For the other job Test_dbi_jobruntimeinfo_2 I’m doing the same but only for one step. So we can expect there an increase of 50% returned by the stored procedure:

After executing the jobs with the changed duration and executing the script, we got the following values back from the stored procedure:

We can see, that we have the increase exactly as expected in the output. But the threshold value is still at “0 = false”, as we didn’t reached the default sensitivity value in minutes of 20 minutes.

I’m changing now the waiting duration back to 35 seconds and execute the jobs and the script again. We can expect now a decrease, as the previous increase will be considered when the stored procedure is calculating the average value. After doing so, the following values are returned as expected:

The stored procedure is telling us, that the decrease was 0 minutes because its working with rounded values. But for the percentage value we can see a small decrease.

I’m now changing the wait time for the job Test_dbi_jobruntimeinfo_2 back to 1 minute and 35 seconds but this time for both steps and execute this job again. We can see that we have now again an increase for this job:

In my execution script, I send a mail over the SQL-Server Mail in case when the threshold is exceeded to inform interested people:

To demonstrate the generated information mail, I overwrite the default sensitivity value in minutes, which is 20 minutes, as I’m too impatient to wait 20 minutes 😉:

After executing the script again, we can see, that the threshold value for the job Test_dbi_jobruntimeinfo_2 is now set to “1 = true”:

And when I check the interface of the test SMTP Server I can see the following mail:

Summary:

For some SQL Agent jobs it can be interesting or necessary to keep an eye on it. Feel free to use the stored procedure and script from this blog or get inspired by them when you are facing a similar situation!

L’article Keep an eye on your SQL Agent jobs using T-SQL! est apparu en premier sur dbi Blog.