DEV Community: Anupam Harsh

How to Check PowerShell Version in Windows 10/11?

Anupam Harsh — Tue, 24 Sep 2024 22:10:12 +0000

To check your PowerShell version on Windows 10/11, open a PowerShell window, type the command $PSVersionTable, and look for the PSVersion field.

Introduction

Checking your PowerShell version on Windows 10/11 is easy. We will find the version of PowerShell in Windows 10/11 using multiple methods like PowerShell, control panel, and registry editor. If one does not work, you can always follow the next method.

But before we move ahead, you can take an overview of Powershell

PowerShell in Brief:

PowerShell is an open-source and automated engine tool. It has helped the developer in automating their tasks. Besides its clean Graphic User Interface, it has a perfect Command Line Interface. It helps the developers and IT admins to convey the commands to the Operating System by conveying commands.

Method 1: PowerShell Console

For the first method, we will use PowerShell itself to find its version.

Step 1: Press Windows + S and type PowerShell.

Step 2: Now, Click on Open.

The screenshot attached below will help you to identify how it looks.

Step 3: Type $PSVersionTable, press Enter, and then look for PSVersion.

$PSVersionTable is a PowerShell automatic variable that provides information about the current session of PowerShell and includes details such as the version, build, etc.

We can use $PSVersionTable.PSVersion to get a more detailed representation of the PowerShell version.

Method 2: Get the Local PowerShell version

Note: This method works only for local PowerShell instances and not for remote PowerShell sessions.

Step 1: Press Windows + S –> Type PowerShell and click on open.

Step 2: Type Get-Host, press ENTER, and look for Version

Other PowerShell commands like $host will give the same result.

These variables are automatically created when we start an instance of PowerShell.

Method 3: Use File Explorer to get the PowerShell File Version

Step 1: Press Windows + e. It will open the File Explorer.

Step 2: Right-click on the top Address bar and paste C:\Windows\System32\WindowsPowerShell\v1.0 and press ENTER.

This will open the directory where the PowerShell.exe file is located. This PowerShell.exe is an executable file for PowerShell CLI(Command Line Interface) that launches a PowerShell session.

Step 3: Locate the file PowerShell.exe in the directory and right-click on it.
It will open a new box. In the new box click on Properties.

It will open a box displaying the properties of PowerShell.exe.

Step 4: Click on the Details tab.

Step 5: Look for File Version

This depicts the version of PowerShell installed on our system.

Method 4: Use Registry Editor to get PowerShell Version

Registry editor is a utility that helps us view and change system-level information on Windows. We’ll now use it to view the version of PowerShell installed on our computer.

Step 1: Press Windows + s, type reged and click on Open.

It will open the graphical interface for the registry editor. If you get any pop-up asking for some permission, allow it.

Step 2: Click on the address bar and paste Computer\HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\PowerShell\3\PowerShellEngine.

It will open the location where configuration and settings related to PowerShell are stored inside the registry.

Step 3: Look for PowerShell Version.

Conclusion

With this, we have covered the most basic and working methods that would help you to find the PowerShell version on your computer.

Mastering SQL Temporal Tables for Effective Data Versioning

Anupam Harsh — Tue, 24 Sep 2024 21:10:36 +0000

In today's fast-paced business environment, the ability to track and audit changes to your data is crucial. Traditional techniques for data versioning, such as maintaining separate history tables or implementing complex triggers, can be cumbersome and error-prone. Fortunately, many database platforms now offer a built-in solution: Temporal Tables.

In this blog post, we'll dive deep into the world of SQL Temporal Tables, exploring their benefits, implementation, and advanced use cases.

Understanding Temporal Tables

Temporal Tables, also known as "system-versioned tables," are a database feature that automatically tracks changes to a table's data over time. Each row in a Temporal Table is associated with a start and end timestamp, allowing you to query the state of the data at any point in the past.

The key components of a Temporal Table include:

History Table: A system-managed table that stores all the previous versions of each row.
Period Columns: Special columns that store the start and end timestamps for each row.
Time Travel Queries: SQL statements that allow you to query the data as it existed at a specific point in time.

Benefits of Using Temporal Tables

Temporal Tables offer several benefits over traditional data versioning approaches:

Automatic Versioning: The database handles the tracking and storage of data changes, reducing the complexity and maintenance burden for developers.
Historical Data Access: You can easily query the historical state of the data, enabling powerful data analysis and auditing capabilities.
Data Integrity: Temporal Tables help maintain data integrity by providing a complete and accurate record of changes over time.
Simplified Application Logic: Developers can focus on the core functionality of their applications, as the versioning mechanics are handled by the database.
Compliance and Regulation: Temporal Tables can help organizations meet regulatory requirements for data retention and auditing.

Implementing Temporal Tables

Setting up Temporal Tables in SQL typically involves a few simple steps:

Step 1: Create the Temporal Table:
Use the CREATE TABLE statement with the PERIOD FOR SYSTEM_TIME clause to define the table and its associated history table.

CREATE TABLE orders (
  order_id INT PRIMARY KEY,
  customer_id INT,
  order_date DATE,
  order_amount DECIMAL(10,2)
)
WITH (SYSTEM_VERSIONING = ON (HISTORY_TABLE = dbo.orders_history));

Step 2: Query the Temporal Table: Use the FOR SYSTEM_TIME clause to access the current or historical state of the data.

-- Query the current state of the table
SELECT * FROM orders;

-- Query the state of the table as of a specific date
SELECT * FROM orders FOR SYSTEM_TIME AS OF '2023-01-01';

-- Query the history of changes to a specific row
SELECT * FROM orders FOR SYSTEM_TIME BETWEEN '2023-01-01' AND '2023-12-31'
WHERE order_id = 123;

Step 3: Manage Temporal Table Maintenance: Regularly maintain the Temporal Table by managing the history data, such as purging old records or archiving to separate storage.

-- Purge history data older than 1 year
ALTER TABLE orders
SWITCH PARTITION $PARTITION.SysEndTime(DATEADD(year, -1, GETUTCDATE()))
TO dbo.orders_history_archive;

Temporal Table Internals

Under the hood, Temporal Tables work by maintaining two tables:

Current Table: The primary table that stores the current state of the data.
History Table: A system-managed table that stores all the previous versions of each row.

When a row in the current table is inserted, updated, or deleted, the database automatically records the changes in the history table. This is done by populating the special period columns (sys_period) with the start and end timestamps for each row version.

The diagram below illustrates the internal structure of a Temporal Table:

graph TD
  A[Current Table] -->|INSERT| B[History Table]
  A -->|UPDATE| B
  A -->|DELETE| B
  B -->|Query| A

By leveraging the history table, you can query the data as it existed at any point in time using the FOR SYSTEM_TIME clause.

Advanced Temporal Table Techniques

While the basics of Temporal Tables are straightforward, there are several advanced techniques and considerations:

Temporal Table Partitioning: Partition the history table to improve query performance and manage large data volumes.

CREATE PARTITION FUNCTION pf_history(datetime2)
AS RANGE FOR VALUES (
  DATEADD(year, -1, GETUTCDATE()),
  DATEADD(year, -2, GETUTCDATE()),
  DATEADD(year, -3, GETUTCDATE())
);

CREATE PARTITION SCHEME ps_history
AS PARTITION pf_history TO ([current_year], [prior_year], [two_years_ago], [three_years_ago]);

Temporal Table Indexing: Create indexes on the history table to further optimize time-based queries.

CREATE INDEX IX_orders_history_order_id_sys_period
ON orders_history (order_id, sys_period);

Temporal Table Triggers: Leverage triggers to perform custom actions when rows are inserted, updated, or deleted.

CREATE TRIGGER TR_orders_history_audit
ON orders_history
AFTER INSERT, UPDATE, DELETE
AS
BEGIN
  INSERT INTO orders_audit (order_id, event_type, event_time)
  SELECT order_id, 'INSERT', sys_start FROM inserted
  UNION ALL
  SELECT order_id, 'UPDATE', sys_start FROM updated
  UNION ALL
  SELECT order_id, 'DELETE', sys_start FROM deleted
END;

Temporal Table Security: Implement fine-grained access control to restrict access to historical data.

DENY SELECT ON orders_history TO regular_users;
GRANT SELECT ON orders_history TO audit_team;

Temporal Table Integration: Integrate Temporal Tables with other data management tools, such as ETL pipelines or data warehousing solutions.

Real-World Temporal Table Use Cases

Temporal Tables have proven to be invaluable in a wide range of applications, including:

Financial Auditing: Maintain a complete audit trail of all transactions and account changes for regulatory compliance and internal auditing.
Retail Inventory Management: Track the history of product pricing, availability, and other attributes to analyze trends and make informed business decisions.
Healthcare Records: Preserve the full history of patient records, allowing healthcare providers to view and analyze a patient's complete medical history.
IoT Sensor Data: Store and analyze the historical data from IoT sensors, enabling deeper insights into system performance and anomaly detection.

By leveraging the power of SQL Temporal Tables, you can unlock a new level of data visibility and control, cheering up your organization to make more informed decisions, maintain regulatory compliance, and deliver a superior customer experience.