European Windows 2019 Hosting BLOG

BLOG about Windows 2019 Hosting and SQL 2019 Hosting - Dedicated to European Windows Hosting Customer

European SQL Server 2022 Hosting :: Understanding, Using, and Implementing Time Series Databases

clock November 29, 2023 07:07 by author Peter

The ability to successfully handle and evaluate time-sensitive information is critical in today's data-driven environment. This is especially true in businesses like finance, IoT, and healthcare, which generate massive amounts of time-stamped data on a daily basis. Traditional relational databases frequently struggle to meet the needs of storing and retrieving such data, resulting in the development of specialist systems known as Time Series Databases (TSDBs).

What exactly are Time Series Databases?
TSDBs are specifically built to excel at keeping and interpreting time-indexed data points, providing optimal performance for time series data. They have a number of advantages over regular databases.

  • Efficient Data Storage: TSDBs use specific data structures and compression techniques to efficiently store time series data, reducing storage requirements.
  • Optimized Querying: TSDBs provide sophisticated query languages designed specifically for time series analysis, allowing users to retrieve and analyze data fast based on time ranges, aggregations, and other criteria.
  • Real-time Analytics: TSDBs are built to handle real-time data input and analysis, allowing businesses to monitor and respond to events as they happen.

Time Series Databases That Are Popular
Several popular TSDBs have evolved, each with its own distinct set of features and advantages. Here are some noteworthy examples.

An open-source TSDB is well-known for its fast querying capabilities and support for massive amounts of time-stamped data.

# Sample InfluxDB Query
from influxdb import InfluxDBClient

client = InfluxDBClient(host='localhost', port=8086)

result = client.query("SELECT * FROM mymeasurement WHERE time > now() - 1d")

A monitoring and alerting toolkit that excels in collecting and storing metrics using a multidimensional data model and a powerful query language (PromQL).
# Sample PromQL Query
http_requests_total{job="api-server", status="200"}

While primarily known as a full-text search and analytics engine, Elasticsearch also offers robust time series data capabilities, handling large-scale time series data with its distributed architecture.

# Sample Elasticsearch Query
"query": {
"range": {
  "@timestamp": {
    "gte": "now-1d/d",
    "lt": "now/d"

Built on top of the Hadoop Distributed File System (HDFS), OpenTSDB is designed for scalability, leveraging HBase for storing and retrieving time series data, making it suitable for large-scale deployments.
# Sample OpenTSDB Query
tsdquery summary  -start 1h-ago -end now -m avg:metric_name

A lightweight TSDB that focuses on simplicity and ease of use supporting the Graphite Query Language (GQL) and is well-suited for small to medium-sized deployments.

# Sample Graphite Query
summarize(metric_name, "1h", "sum")

Use Cases of Time Series Databases

TSDBs find applications across a wide range of industries and use cases.

  • Financial Analytics: Analyzing historical market data, tracking transactions, and predicting trends are essential for financial institutions. TSDBs enable real-time monitoring of stock prices, currency exchange rates, and other financial metrics.
  • IoT Data Management: With the proliferation of IoT devices, TSDBs are instrumental in handling the vast amount of data generated by sensors and devices. These databases enable organizations to monitor and analyze data from IoT devices in real-time, leading to informed decision-making.
  • Infrastructure Monitoring: TSDBs find extensive use in monitoring and managing the performance of IT infrastructure. They help organizations track metrics related to server health, network latency, and application response times, facilitating proactive issue detection and resolution.
  • Healthcare Systems: In healthcare, time series databases are employed to store and analyze patient data, monitor vital signs, and track the efficacy of treatments over time. These databases contribute to improved patient care and the advancement of medical research.

Time series databases have become indispensable tools in the modern data landscape, offering specialized solutions for handling the unique challenges posed by time-stamped data. From monitoring and analytics to financial modeling and IoT applications, the use cases for TSDBs continue to expand as the volume of time series data generated across industries continues to grow.

Each database mentioned here brings its own strengths to the table, catering to diverse needs in terms of scalability, performance, and ease of use. As organizations strive to harness the power of their time-series data, TSDBs will play an increasingly crucial role in enabling data-driven decision-making and unlocking new insights.

HostForLIFEASP.NET SQL Server 2022 Hosting


European SQL Server 2022 Hosting :: How to Avoid the SQL Server Query Governor Cost Limit Error

clock November 14, 2023 06:59 by author Peter

If you've ever seen the error message
"The query has been canceled because its estimated cost (X) exceeds the configured X-1 threshold." "Speak with the system administrator."

You might be wondering what a SQL Server query means and how to remedy it when running it. In this essay, I'll look at the source of the problem and how to solve it.

What is the query governor's cost limit?
The query governor cost limit is a SQL Server setting that specifies the maximum time for a query to run. The duration, stated in seconds, is based on an approximation of the query cost for a specific hardware configuration. This setting is intended to prevent persistent queries from consuming too many resources and interfering with the functioning of other queries and applications.

Because the query governor cost limit is set to 3000 by default, any query that is projected to take more than 3000 seconds—or 50 minutes—will be canceled. This value can be changed by the system administrator using the stored function sp_configure.

Why am I getting the error?
If your query has a high expected cost and is too complex or inefficient, you may receive an error warning. The number and size of the tables involved, the indexes and statistics available, the join and aggregation techniques used, the filters and sorting algorithms used, and the SQL Server version and edition all have an impact on how much a query is estimated to cost.

Running a query that entails scanning a large table with no indexes or filters, for example, could result in a high estimated cost. Similarly, performing a query that calls a function or subquery for each row in the return set could result in an extremely high projected cost.

How do I fix the mistake?
The two most likely remedies are to increase the query governor's cost limit or optimize your query. Increase the query governor's cost limit: To increase the query governor cost limit for the active connection, use the SET QUERY_GOVERNOR_COST_LIMIT command. For example, if the estimated cost of the query is 14.000, you may execute the following line before running the query:


Here is an example of how to utilize it:
using Microsoft.Data.SqlClient;
using System.Data;

var connectionString = "Server=YourServerName;Database=YourDatabaseName;User=YourUserName;Password=YourPassword;";

// Create a SqlConnection and SqlCommand
using SqlConnection connection = new SqlConnection(connectionString);


// Set the QUERY_GOVERNOR_COST_LIMIT before executing the query
var setQueryGovernorCostLimit = "SET QUERY_GOVERNOR_COST_LIMIT 15000;";
using (SqlCommand setQueryGovernorCommand = new SqlCommand(setQueryGovernorCostLimit, connection))

// Complex SELECT query
var selectQuery = @"
    -- Add more fields related to the customized automobiles here
    INNER JOIN Customers ON Orders.CustomerID = Customers.CustomerID
    INNER JOIN Cars ON Orders.CarID = Cars.CarID
    INNER JOIN Colors ON Orders.ColorID = Colors.ColorID
    INNER JOIN Engines ON Orders.EngineID = Engines.EngineID
    INNER JOIN Wheels ON Orders.WheelID = Wheels.WheelID
    INNER JOIN Interiors ON Orders.InteriorID = Interiors.InteriorID
    LEFT JOIN OrderAccessories ON Orders.OrderID = OrderAccessories.OrderID
    LEFT JOIN Accessories ON OrderAccessories.AccessoryID = Accessories.AccessoryID
    LEFT JOIN CarFeatures ON Cars.CarID = CarFeatures.CarID
    LEFT JOIN Features ON CarFeatures.FeatureID = Features.FeatureID
    LEFT JOIN CarOptions ON Cars.CarID = CarOptions.CarID
    LEFT JOIN Options ON CarOptions.OptionID = Options.OptionID
    -- Your filter conditions for customizations or specific orders here

using SqlCommand command = new SqlCommand(selectQuery, connection);

using SqlDataAdapter adapter = new SqlDataAdapter(command);

DataTable dataTable = new DataTable();

This will prevent the cancellation of your query. This method is not advised because it can impact the performance of other queries and apps. Additionally, this statement needs to be executed for each connection that requires the query to be done.

  • Optimize your query: Reducing the anticipated cost of your query optimization is a preferable course of action. The following methods can help you enhance the efficiency of your queries.
  • Use indexes: By reducing the amount of scanning and sorting necessary, indexes can help SQL Server locate the data more quickly. The columns used in your query's join, filter, and order by clauses can all have indexes created on them. The Database Engine Tuning Advisor can also recommend the best indexes for your query.
  • Use statistics:  SQL Server can estimate the number of rows and value distribution in tables with statistics. This can assist the SQL Server in selecting the query's optimal execution strategy. The UPDATE STATISTICS statement and the sp_updatestats stored procedure can be used to update the statistics in your tables.
  • Simplify your query: You can make your query simpler by eliminating any extraneous tables, joins, filters, columns, or sorting. Your query can be rewritten to take advantage of more effective operators, like EXISTS rather than IN, or it can be divided into shorter searches using temporary tables or common table expressions (CTEs).
  • Use the latest SQL Server version and edition: Use the most recent edition and version of SQL Server: These may offer improved performance and optimization features over previous iterations. For instance, the projected cost of your query for SQL Server 2022 Web Edition can be less than that of SQL Server 2019 Web Edition. The @@VERSION function allows you to verify your database's SQL Server version and edition.

The query governor cost limit error is a common problem in SQL Server that occurs when your query exceeds the configured threshold and has a high estimated cost. Increasing the query governor cost limit or optimizing the query are two solutions to this problem. Nonetheless, query optimization is the ideal option because it can improve query performance and efficiency while avoiding potential resource issues.

HostForLIFEASP.NET SQL Server 2022 Hosting

European SQL Server 2022 Hosting :: Recover Deleted or Modified Data Using Transaction Log

clock November 1, 2023 08:28 by author Peter

In this piece, we'll go over LSN, the Retrieved function fn_dblog(), and the Recovery Models that go with it in further depth.

Log of SQL Server Transactions
Every SQL Server database has a transaction log that records all transactions as well as the database changes made by each transaction. The transaction log is a crucial component of the database, and if there is a system failure, the transaction log may be necessary to restore consistency to your database.

The SQL Server Transaction Log is useful for recovering deleted or updated data if you run a DELETE or UPDATE operation with the incorrect condition or without filters. This is accomplished by listening to the records included within the SQL Server Transaction Log file. DML operations such as INSERT, UPDATE, and DELETE statements, as well as DDL operations such as CREATE and DROP statements, are among the events that are written to the SQL Server Transaction Log file without any additional configuration from the database administrator.

LSN Function Retrieving from Transaction Log
fn_dblog() is a function.

The fn_dblog() function is one of the SQL Server undocumented functions; it allows you to see transaction log records in the active section of the transaction log file.
fn_dblog() Arguments

The fn_dblog() function takes two arguments.

  • The first is the initial log sequence number, abbreviated as LSN. You can alternatively use NULL to return everything from the beginning of the log.
  • The second is the LSN at the conclusion. You can alternatively specify NULL, which indicates that you wish to return everything to the log's conclusion.

SELECT * FROM fn_dblog (
              NULL, -- Start LSN nvarchar(25)
              NULL  -- End LSN nvarchar(25)

We will not discuss the details of the function but list the possibly useful columns below:

Operation Clumn in fn_dblog()
The ‘Operation’ column indicates the type of operation that has been performed and logged in the transaction log file.

Such as test.





Recovery Models
SQL Server backup and restore operations occur within the context of the recovery model of the database. Recovery models are designed to control transaction log maintenance. A recovery model is a database property that controls how transactions are logged, whether the transaction log requires (and allows) backing up, and what kinds of restore operations are available.

Three recovery models exist:
    Simple --- Operations that require transaction log backups are not supported by the simple recovery model.
    Full, and

Typically, a database uses the full recovery model or simple recovery model. A database can be switched to another recovery model at any time. By default, when a new database is created within Microsoft SQL, the recovery model option is set to full.

Recovery Option
Restoring the db with the RECOVERY option is the default option for users with FULL backup. However, if you have different types of backups (differential, transactional, etc.), you may need to use the NORECOVERY option to combine the backups.

Even Recover database without Restore

HostForLIFEASP.NET SQL Server 2022 Hosting

European SQL Server 2022 Hosting :: How to check if SQL table is temporal?

clock October 30, 2023 10:49 by author Peter

There are two methods for determining whether a SQL table is temporal: Examine the table definition. There are two system-versioned period entries in temporal tables: sys_start_time and sys_end_time. These columns include the beginning and end dates of the time period for which the row is valid. A table with these two columns is a temporal table.

The OBJECTPROPERTY() function should be used. The OBJECTPROPERTY() function returns information about a database object, such as whether it is a temporal table. To determine whether a table is temporal, use the SQL statement:

SELECT OBJECTPROPERTY(object_id('table_name'), 'IsTemporalTable');

If the query returns a value of 1, the table is temporal. Otherwise, the table is not chronological. For instance, the following SQL statement will determine whether the Products table is temporal:

SELECT OBJECTPROPERTY(object_id('Products'), 'IsTemporalTable');

If the result of the query is 1, then the Products table is temporal. Otherwise, the Products table is not temporal.

Note: Temporal tables are only supported in Microsoft SQL Server 2016 and later versions.

Here are some additional things to keep in mind about temporal tables:

  • Temporal tables can be either system-versioned or history-table versioned. System-versioned temporal tables are managed by the database engine, while history-table versioned temporal tables are managed by the user.
  • Temporal tables can be used to store both current and historical data. Current data is stored in the table, while historical data is stored in a history table.
  • Temporal tables can be used to query both current and historical data. The FOR SYSTEM_TIME clause can be used to specify the time period for which the data should be returned.

HostForLIFEASP.NET SQL Server 2022 Hosting

European SQL Server 2022 Hosting :: SQL Server optional parameters

clock October 27, 2023 07:50 by author Peter

This article will teach you about optional parameters and how to use them in stored procedures.

Parameters that are optional
Optional parameters are a sort of parameter in which you can declare a default value, and if that parameter is not passed, the default value is used.
By using several examples, let's establish a "Employees" database and learn how to write a stored method with Optional Parameters.

CREATE TABLE Employees (
EMPAddress VARCHAR (Max),
ContactNumber VARCHAR (10),

--Inserting multiple records in one table.

INSERT INTO Employees (EMPID, EMPName, EMPAddress, ContactNumber, EMPSalary)
VALUES (101, 'Peter', 'London', NULL, 65000),
(102, 'Scott', 'Manchester', 1234567809, 55000),
(103, 'Laura', 'Leeds', NULL, 95000),
(104, 'Samuel', 'Liverpool', 1234506789, 35000)

Now check the table by running a select query.
SELECT * FROM Employees;

Now create stored proc, which inserts records in the table with mandatory parameters.
CREATE OR ALTER PROCEDURE usp_InsertEmployeesRecords
@EMPName VARCHAR (50),
@EMPAddress VARCHAR (Max),
@ContactNumber VARCHAR (10),
@EMPSalary INT
    INSERT INTO Employees VALUES (@EMPID, @EMPName, @EMPAddress, @ContactNumber, @EMPSalary)
    SELECT * FROM Employees                     --Checking if all the records inserted in Employee table or not.


The stored procedure “usp_InsertEmployeesRecords” was created
Now let’s execute the same procedure and see the output.

EXECUTE usp_InsertEmployeeRecords 105, 'Maria', 'Leeds', 1203456789, 70000

As you can see above, all records are inserted in the table as values passed for all mandatory parameters.
Now let’s go with another scenario when a user doesn’t have all the information and inserts records in the table for example missing contact number.
Executing the same procedure again.

EXECUTE usp_InsertEmployeesRecords @EMPID = 106, @EMPName = 'Ricky', @EMPAddress = 'London', @EMPSalary = 80000;

After executing the procedure, we got the following error, which means we had created proc with mandatory parameters, and we have not passed the values for all the parameters.

Now to overcome with above error, let's create the proc with an optional parameter.

CREATE OR ALTER PROCEDURE usp_InsertEmployeesRecordsOptParam
@EMPName VARCHAR (50),
@EMPAddress VARCHAR (Max),
@ContactNumber VARCHAR (10) = 'NULL',
@EMPSalary INT
    INSERT INTO Employees VALUES (@EMPID, @EMPName, @EMPAddress, @ContactNumber, @EMPSalary)
    SELECT * FROM Employees                     --Checking if all the records inserted in Employee table or not.

The stored procedure “usp_InsertEmployeesRecordsOptParam” was created, as you can see in the above screenshot.


HostForLIFEASP.NET SQL Server 2022 Hosting

European SQL Server 2022 Hosting :: What exactly is a temporal table?

clock October 17, 2023 09:35 by author Peter

A temporal table is a sort of database table that is intended to track changes over time without the need for sophisticated custom programming or triggers. It accomplishes this by including system-generated columns in the table that reflect each row's valid time period. System-Versioned Temporal Tables are another name for them.

Temporal Tables with System Verification

The system automatically tracks changes to the data over time in this form of temporal table by creating a new version of each row every time it is modified or removed. The original row is kept with its valid time period, and a new version with its own valid time period is created. This enables you to view the table's history at any moment and query it as if it were a snapshot of the data at that time.

CREATE TABLE dbo.MyTemporalTable (
Name VARCHAR(50),
PERIOD FOR SYSTEM_TIME (EffectiveStartTime, EffectiveEndTime)
) WITH (SYSTEM_VERSIONING = ON (HISTORY_TABLE = dbo.MyTemporalTable_History));

How to query the temporal table?
Temporal tables, like database tables, can be queried. To query data across the main and history tables, a new clause FOR SYSTEM_TIME with five temporal-specific sub-clauses has been added. This new SELECT statement syntax is usable on a single table, via multiple joins, and via views on top of several temporal tables.

The five sub-clauses
AS OF <DateTime>
FROM <EffectiveStartTime> TO <EffectiveEndTime>
BETWEEN <EffectiveStartTime> AND <EffectiveEndTime>
CONTAINED IN (EffectiveStartTime, <EffectiveEndTime>)

-- AS OF (EffectiveStartTime<= date_time AND EffectiveEndTime> date_time)
SELECT * FROM dbo.MyTemporalTable FOR SYSTEM_TIME AS OF '2023-03-10 T10:00:00.0000000'

-- FROM (EffectiveStartTime< date_time AND EffectiveEndTime > date_time)
SELECT * FROM dbo.MyTemporalTable FOR SYSTEM_TIME FROM '2022-01-01' TO '2022-12-31'

--BETWEEN (EffectiveStartTime<= date_time AND EffectiveEndTime > date_time)
SELECT * FROM dbo.MyTemporalTable FOR SYSTEM_TIME BETWEEN '2022-01-01' AND '2022-12-31'

--CONTAINED (EffectiveStartTime>= date_time AND EffectiveEndTime <= date_time)
SELECT * FROM dbo.MyTemporalTable FOR SYSTEM_TIME CONTAINED IN ('2023-01-01', '2023-02-28')

--ALL (All rows)

How to drop the temporal table?
Dropping a temporal table is similar to dropping any other table in your database. However, we need to consider a few things before dropping a temporal table to avoid data loss and ensure that the cleanup process is handled correctly.

Here are the general steps to drop a temporal table.

Drop the dependent objects: Before dropping the temporal table, you should first drop any dependent objects, such as triggers, indexes, or foreign keys that reference the temporal table.

Disable temporal feature: Disable the temporal feature of the table by running the ALTER TABLE statement to remove the system-versioning or application-time period specification.

Drop the temporal table: After removing all dependent objects and disabling the temporal feature of the table, drop the table using the DROP TABLE statement.
DROP TABLE IF EXISTS dbo.MyTemporalTable;

Limitations of temporal table

  • Storage requirements: System-versioned temporal tables require additional storage to maintain historical versions of the data. The size of the history table can grow quickly, especially for tables with many updates or deletes, which can impact performance and increase storage costs.
  • Query performance: Querying a temporal table can be more complex than querying a regular table, especially if you need to retrieve data from both the current and historical versions of the data. Depending on the database system, query performance may be slower for temporal tables than for regular tables.
  • Configuration complexity: Setting up a temporal table requires some additional configuration steps compared to a regular table. This can make it more complex to create and maintain the table, especially if you are not familiar with the temporal table syntax.
  • Compatibility: Not all database systems support temporal tables. While SQL Server, Oracle, and PostgreSQL all support temporal tables, other systems may not. This can limit your ability to use temporal tables if you need to migrate to a different database system in the future.
  • Migration complexity: If you have an existing table that you want to make temporal, you may need to perform a data migration to move the existing data to the history table. This can be complex and time-consuming, especially for large tables.

Advantages of temporal table
The main advantage of a temporal table is that it allows you to maintain a full history of changes to your data over time. This provides several benefits, including:

  • Auditing: With a temporal table, you can easily track changes to your data over time. This is useful for auditing purposes, as you can see when and how data was modified, deleted, or added.
  • Compliance: Many industries have regulatory requirements that mandate data retention policies. By maintaining a full history of changes to your data, you can ensure compliance with these requirements.
  • Recovery: In the event of data loss or corruption, a temporal table can be used to recover lost data. You can restore the table to a previous point in time and recover data that was lost or corrupted.
  • Analysis: A temporal table can be used for trend analysis, as you can see how data has changed over time. This can be useful for identifying patterns, trends, and anomalies in your data.
  • Data versioning: With a temporal table, you can easily maintain multiple versions of your data. This is useful if you need to maintain different versions of a record for different users or if you need to create a new version of a record without overwriting the previous version.

Overall, the temporal table provides a powerful mechanism for maintaining a full history of changes to your data. This can be useful for a variety of purposes, including auditing, compliance, recovery, analysis, and data versioning. By understanding the limitations of temporal tables, you can make an informed decision about whether they are the right solution for your needs.

European SQL Server 2022 Hosting :: How to Dynamic Sorting in SQL Server?

clock October 11, 2023 12:09 by author Peter

Dynamic sorting in SQL Server allows you to dynamically and flexible sort the result set of a query depending on one or more columns. This means that rather than hardcoding the sorting order of the result set in the query, you can determine it at runtime.

There are various approaches to implementing dynamic sorting in SQL Server, but the most frequent is to utilize the ORDER BY clause with a variable containing the column name(s) to sort on.

Here’s an example
DECLARE @SortColumn NVARCHAR(50) = 'LastName'

FROM Customers
  CASE WHEN @SortOrder = 'ASC' THEN
    CASE @SortColumn
      WHEN 'FirstName' THEN FirstName
      WHEN 'LastName' THEN LastName
      WHEN 'City' THEN City
  CASE WHEN @SortOrder = 'DESC' THEN
    CASE @SortColumn
      WHEN 'FirstName' THEN FirstName
      WHEN 'LastName' THEN LastName
      WHEN 'City' THEN City

In this example, the @SortColumn variable determines which column to sort on, and the @SortOrder variable determines whether to sort in ascending or descending order. The CASE statements in the ORDER BY clause dynamically generate the sort expression based on the values of these variables.

Note that dynamic sorting can be potentially risky, as it can expose your database to SQL injection attacks. It’s important to validate and sanitize any user input that is used to determine the sorting order.

HostForLIFEASP.NET SQL Server 2022 Hosting

European SQL Server 2022 Hosting :: Data Transfer from One Table to Another Across Databases

clock October 6, 2023 08:40 by author Peter

The migration of data from one database to another is a regular job performed by a Database Administrator. This scenario frequently occurs when businesses need to integrate data from several sources, migrate data to a data warehouse, or do data analytics on a collection of data held in various databases. Ingesting data from one table in a database to another table in a different database is a common scenario, especially when both tables have identical columns. with this article, we'll go over how to do this efficiently with SQL Server Management Studio.

Create the Database Connection
Before you can transfer data between tables in different databases, you must first ensure that you have the required permissions and connectivity to both databases, which frequently entails defining connection settings such as server addresses, authentication credentials, and database names.

Recognize the Tables
It is critical that you have a thorough understanding of both the source and destination tables. The tables in our case share the same columns, which simplifies the operation. You should still double-check that the column names, data types, and constraints are consistent between the two tables. Any inconsistencies can cause data integrity difficulties during the transmission.

Create and run the SQL query
To transfer the data, create a SQL query with the INSERT INTO... function. SELECT the typically used statement for that purpose. The source table, the fields to be transferred, and the destination table should all be specified in the query. After you've written the SQL query, click the Execute button to run it. In our case, we wish to move the data from the SalesData database's DimCustomer table to the data warehouse database's DimCustomer table. The table structure in both tables is the same.

We wrote a simple query in the screenshot below to retrieve all of the records from that table. In the next screenshot below, we switched to the destination database: DataWarehouse, and we selected all the columns in the dimCustomer table without any data ingested thus far. This is necessary to verify the structure of the destination table.

SELECT * FROM DimensionCustomer;

In the following snapshot, we went to the destination database, DataWarehouse, and selected all of the columns in the dimCustomer table with no data ingested thus far. This is required to validate the destination table's structure.

In the next screenshot below, we wrote and executed the query, and from the message displayed, a total of 18,484 records were inserted into the destination table.

INSERT INTO DataWarehouse.dbo.DimCustomer (
FROM SalesData.dbo.DimensionCustomer;

Verify the Results
After the query execution is complete, it's essential to verify the results. To verify, we executed a simple below mentioned query, and all the records were returned.
SELECT * FROM dimCustomer;

HostForLIFEASP.NET SQL Server 2022 Hosting

European ASP.NET Core Hosting - HostForLIFE :: ACID Properties in SQL Server

clock September 19, 2023 09:31 by author Peter

Today, I'd want to revisit one of the most typical interview questions and replies, which I see frequently referenced in subsequent interviews.


A transaction is a collection of SQL statements that operate as a single unit. In layman's terms, a transaction is a unit in which a series of tasks is completed in order to finish the entire activity. To better appreciate this, consider a bank transaction.

SQL Server ACID Properties
SQL Server's ACID properties assure data integrity during a transaction. A transaction is a series of SQL (insert, update, and delete) statements that are handled as a single unit and are executed using the completed or Not principle. To be successful, a transaction must adhere to the ACID Properties. Atomicity, Consistency, Isolation, and Durability are abbreviated as ACID.

Every transaction adheres to atomicity. It indicates that if a transaction is initiated, it must be completed or rolled back. To illustrate, if a person transfers money from account "A" to account "B," the money should be credited to account B after the transaction is completed. If a failure occurs, the modification should be rolled back after debiting the money from account "A." In other words, each transaction will either succeed or fail.

Consistency says that after the completion of a transaction, changes made during the transaction should be consistent. Let’s understand this fact by referring to the above example, if account “A” has been debited by 200 RS, then after the completion of the transaction, account “B” should be credited by 200 RS. It means changes should be consistent. In simple words, Consistency means a guarantee that a transaction never leaves your database in a half-finished state.


Isolation states that every transaction should be isolated from each other. There should not be any interference between the two transactions. In simple words, Any other operation cannot affect my operation.

Durability means that once the transaction is completed, all the changes should be permanent. It means that in case of any system failure, changes should not be lost. In simple words, When the Transaction is complete, the changes are saved.Now we can understand this with the help of a Figure. This is very easy for us. This Figure is shown below.

Q. What is the difference between the Local and the Distributed SQL Server transactions?
The Local transaction is an SQL Server transaction that processes data from the local database server

The Distributed transaction is an SQL Server transaction that processes data from more than one database server

Q. Some transactions may not complete their execution successfully. Explain these transactions.
These transactions are known as,


Whenever a transaction finishes its final statement, it ultimately enters into this state:

Partially committed.
Q. What is the SQL Server Transaction Log LSN?
Each Transaction log record that is written to the SQL Server transaction log file can be identified by its Log Sequence Number (LSN).

European SQL Server 2022 Hosting :: DateTime in SQL Server

clock September 14, 2023 07:59 by author Peter

When working with SQL, one of the most significant data types you'll come across is DateTime. DateTime, which represents dates and times, is critical for managing time-sensitive data such as event scheduling, transaction timestamps, and historical records. In this post, we will go deep into DateTime in SQL to help you become a professional SQL developer, looking at its features, functions, real-world examples, and recommended practices.

Understanding DateTime in SQL Server
DateTime is a SQL data type that combines date and time data into a single value. It is required for capturing temporal moments accurately. SQL databases provide a variety of DateTime data types, including DATE, TIME, DATETIME, and TIMESTAMP, each with its own function.

Date and Time Functions
With the help of SQL's DateTime methods, you have numerous options for handling and modifying date and time data. Understanding the syntax and breadth of applications for these functions is critical to realizing their full potential.

Retrieves the current date and time.


SELECT GETDATE() AS CurrentDateTime;




Adds or subtracts a specified time interval to/from a DateTime value.

DATEADD(interval, number, date)

interval: Specifies the unit of time (e.g., year, month, day) to add or subtract.
number: Represents the quantity of intervals to add (positive) or subtract (negative).
date: The starting date or time to which the operation is applied.

SELECT DATEADD(year, 2, '2023-09-13') AS NewDate;
In this example, we add 2 years to the given date, resulting in '2025-09-13'.

SELECT DATEADD(day, -10, '2023-09-13') AS NewDate;


Here, we subtract 10 days from the given date, resulting in '2023-09-03'.

SELECT DATEADD(hour, 3, '2023-09-13 10:00:00') AS NewTime;


This adds 3 hours to the given time, resulting in '2023-09-13 13:00:00'. As per the above example of DateAdd, we can modify the datetime value in different ways.

Calculates the difference between two DateTime values in a specified unit (e.g., years, months, days).

DATEDIFF(interval, start_date, end_date)

interval: Specifies the unit of time (e.g., year, month, day) to calculate the difference in.
start_date: The beginning date or time.
end_date: The ending date or time.

SELECT DATEDIFF(day, '2023-09-10', '2023-09-13') AS DaysDifference;


In this example, we calculate the difference in days between '2023-09-10' and '2023-09-13', resulting in '3'.

SELECT DATEDIFF(month, '2023-01-15', '2023-09-20') AS MonthsDifference;


Here, we calculate the difference in months between '2023-01-15' and '2023-09-20', resulting in '8'.

SELECT DATEDIFF(year, '1995-08-19', GETDATE()) AS AgeInYears;


In this example, we determine the age of a person born on '1995-08-19' by calculating the difference in years between their birthdate and the current date using GETDATE(). The result is the person's age in years.

Converts DateTime values between different formats.

CONVERT(data_type, expression, style)

data_type: Specifies the target data type to which you want to convert the expression.
expression: The value or column to be converted.
style: Defines the format for the conversion (optional).



In this example, we convert the current date and time obtained using GETDATE() into a Date data type. This results in extracting only the date portion, like '2023-09-13'.

SELECT CONVERT(DATETIME, '2023-09-13 15:16:00', 120) AS ConvertedDateTime;


Here, we convert the string '2023-09-13 15:16:00' into a DateTime data type using style '120'. This results in a DateTime value like '2023-09-13 15:16:00.000'.

Formats DateTime values into user-friendly strings.

FORMAT(expression, format)
expression: The value or column you want to format, often a DateTime value.
format: Specifies the desired format for the expression.



In this example, we format the current date and time obtained using GETDATE() into a short date format (MM/DD/YY or equivalent based on localization). The result could be something like '09/13/23'.

SELECT FORMAT(GETDATE(), 'MMMM dd, yyyy HH:mm:ss') AS CustomFormattedDateTime;


Here, we take the current date and time and format it into a custom string that includes the full month name, day, year, and time in the 'MMMM dd, yyyy HH:mm:ss' format. The result might look like 'September 13, 2023 15:23:52'.



In this example, we format the current date and time into a time-only format (HH:mm:ss), showing only the hours, minutes, and seconds. The result could be something like '15:25:43'.

Upcoming Events
Retrieve events that are scheduled for the future.

    EventName VARCHAR(100),
    EventDateTime DATETIME

INSERT INTO Events (EventID, EventName, EventDateTime)
    (1, 'Tech Conference', '2023-09-20 14:30:00'),
    (2, 'Product Launch', '2023-10-05 09:00:00'),
    (3, 'Workshop of SQL', '2023-09-25 10:00:00'),
    (4, 'Seminar', '2023-11-15 15:45:00'),
    (5, 'Annual Conference', '2022-08-01 18:00:00'),
    (6, 'Annual MVP Seminar', '2022-10-14 11:30:00');

Select * From Events

SELECT EventName, EventDateTime
FROM Events WHERE EventDateTime > GETDATE() Order By EventDateTime;


Best Practices

When working with DateTime functions in SQL, consider these best practices:

  • Data Validation: Ensure that your DateTime values are valid to avoid unexpected results.
  • Avoid Mixing Data Types: Be cautious when mixing different DateTime data types in calculations.
  • Optimize Queries: Index DateTime columns for improved query performance, especially in large datasets.
  • Handle Time Zones: Address time zone issues when dealing with international data.

DateTime type in SQL, enabling you to handle date and time-related data effectively. By understanding its properties, functions, and best practices, you can ensure data accuracy and precision in your SQL databases.

If you find this article valuable, please consider liking it and sharing your thoughts in the comments.

Thank you, and happy coding.

HostForLIFEASP.NET SQL Server 2022 Hosting

About HostForLIFE

HostForLIFE is European Windows Hosting Provider which focuses on Windows Platform only. We deliver on-demand hosting solutions including Shared hosting, Reseller Hosting, Cloud Hosting, Dedicated Servers, and IT as a Service for companies of all sizes.

We have offered the latest Windows 2019 Hosting, ASP.NET 5 Hosting, ASP.NET MVC 6 Hosting and SQL 2019 Hosting.

Tag cloud

Sign in