Address block 3 suggestions

Author: markingmyname

learn-pr/azure-databases/postgresql/basic-sql-aggregate-functions-grouping/2-sample-database-overview.yml

@@ -1,8 +1,8 @@
 ### YamlMime:ModuleUnit
 uid: learn.wwl-azure.basic-sql-aggregate-functions-grouping.sample-database-overview
-title: Sample Database Overview
+title: Sample database
 metadata:
-  title: Sample Database Overview
+  title: Sample database overview
   description: "This unit introduces the structure and purpose of the sales sample database used throughout the module. It describes the key tables, their relationships via foreign keys, and how the database supports tracking orders, inventory, and customer activity. A schema diagram and SQL script are provided to help learners explore and understand the data model."
   ms.date: 05/14/2025
   author: milenak

learn-pr/azure-databases/postgresql/basic-sql-aggregate-functions-grouping/includes/2-sample-database-overview.md

@@ -1,4 +1,5 @@
 The sales database is designed to simulate a typical sales environment for a company that sells various products to customers. It's structured to store information about customers, products, suppliers, orders, employees, and shipping. This database allows you to:
+
 - Track customer orders and purchase history
 - Manage product inventory and pricing
 - Analyze sales data and generate reports
@@ -1046,7 +1047,3 @@ INSERT INTO Sales.OrderDetails VALUES(518,10443,28,12);
 ```
 
 </details>
-
-## Sample database diagram
-
-:::image type="content" source="../media/sample-database.png" alt-text="Screentshot of a sample database":::

learn-pr/azure-databases/postgresql/basic-sql-aggregate-functions-grouping/includes/3-aggregate-functions.md

@@ -1,4 +1,6 @@
-Instead of retrieving individual rows, you frequently need to summarize data to understand trends or patterns. Aggregate functions are designed for this purpose, allowing you to perform calculations on a group of rows and return a single result. Common examples include determining the total sales, the average price of products, or the number of orders placed. These functions are fundamental tools for data analysis in SQL.
+Instead of retrieving individual rows, you frequently need to summarize data to understand trends or patterns.
+
+Aggregate functions are designed for this purpose, allowing you to perform calculations on a group of rows and return a single result. Common examples include determining the total sales, the average price of products, or the number of orders placed. These functions are fundamental tools for data analysis in SQL.
 
 Examples of aggregate functions include `COUNT` to count rows, `SUM` to calculate totals, `AVG` for averages, `MIN` to find the smallest value, and `MAX` to find the largest value in a dataset.
 

learn-pr/azure-databases/postgresql/basic-sql-aggregate-functions-grouping/includes/5-summary.md

@@ -1,4 +1,5 @@
 This tutorial provided a comprehensive overview of aggregate functions and data grouping techniques in SQL, specifically in the context of PostgreSQL.
+
 You should now be able to use functions such as `COUNT`, `SUM`, `AVG`, `MIN`, and `MAX` to perform calculations across multiple rows, as well as organize and summarize data using the `GROUP BY` and `HAVING` clauses.
 
 By learning these concepts, you're well-equipped to analyze trends, generate meaningful summaries and filter grouped results effectively within relational databases.

learn-pr/azure-databases/postgresql/basic-sql-join-tables/2-sample-database-overview.yml

@@ -1,8 +1,8 @@
 ### YamlMime:ModuleUnit
 uid: learn.wwl-azure.basic-sql-joining-tables.sample-database-overview
-title: Sample Database Overview
+title: Sample database
 metadata:
-  title: Sample Database Overview
+  title: Sample database overview
   description: "This unit introduces the structure and purpose of the sales sample database used throughout the module. It describes the key tables, their relationships via foreign keys, and how the database supports tracking orders, inventory, and customer activity. A schema diagram and SQL script are provided to help learners explore and understand the data model."
   ms.date: 05/14/2025
   author: milenak

learn-pr/azure-databases/postgresql/basic-sql-join-tables/includes/1-introduction.md

@@ -1,6 +1,4 @@
-
 <!-- 1. Topic sentences ----------------------------------------------------------------------------------
-
     Goal: Orient the learner to the area covered in this module.
 
     Heading: None
@@ -44,12 +42,13 @@ In addition to managing individual tables, the ability to join tables is a criti
     Example: "In this module, we'll formally define several cybersecurity concepts like authentication
              and authorization. Then we'll put the concepts into context by describing some common
              authentication-based attacks. We'll also define some effective authorization security techniques."
- -->
- ## What to expect?
+-->
+
+## What to expect?
 
 In this section, you learn how to combine data from multiple related tables using various types of SQL joins. You explore usage of `INNER JOIN`, `LEFT JOIN`, `RIGHT JOIN`, `FULL OUTER JOIN`, and `NATURAL JOIN` to retrieve connected data across tables. Through practical examples using the `sales` database, you gain the skills to query and interpret relationships between entities like `customers`, `orders`, and `employees`.
 
- <!-- 5. Terminal learning objective ----------------------------------------------------------------------
+<!-- 5. Terminal learning objective ----------------------------------------------------------------------
 
     Goal: Restate the module title as a complete sentence. You have more room here to convey the main goal
           than in a space-limited title. Make it outcome-focused so it describes the main skills and
@@ -59,7 +58,8 @@ In this section, you learn how to combine data from multiple related tables usin
     Heading: "## What is the main goal?"
 
     Example: "By the end of the module, you'll have a comprehensive understanding of core cybersecurity concepts."
- -->
+-->
+
 ## What is the main goal?
 
 The main goal of this section is to help you understand how to retrieve meaningful, connected data from multiple tables in a relational database using SQL joins. By understanding different types of joins and when to use them, you're able to write efficient queries that reflect real-world relationships between entities, enabling more complete and insightful data analysis.

learn-pr/azure-databases/postgresql/basic-sql-join-tables/includes/2-sample-database-overview.md

@@ -1,21 +1,21 @@
 The sales database is designed to simulate a typical sales environment for a company that sells various products to customers. It's structured to store information about customers, products, suppliers, orders, employees, and shipping. This database allows you to:
 
-* Track customer orders and purchase history
-* Manage product inventory and pricing
-* Analyze sales data and generate reports
-* Track which employee handled which order
-* Track which shipper was used for each order
+- Track customer orders and purchase history
+- Manage product inventory and pricing
+- Analyze sales data and generate reports
+- Track which employee handled which order
+- Track which shipper was used for each order
 
-## Key tables:
+## Key tables
 
-* customers: Stores customer details like names, addresses, and contact information
-* products: Contains product information, including names, prices, and categories
-* categories: Lists the categories to which the products belong
-* suppliers: Holds information about the companies supplying the products
-* orders: Records customer order details, including dates and customer IDs
-* order_details: Provides line-item details for each order, linking products and quantities
-* employees: Stores employee information
-* shippers: Contains details about shipping companies
+- customers: Stores customer details like names, addresses, and contact information
+- products: Contains product information, including names, prices, and categories
+- categories: Lists the categories to which the products belong
+- suppliers: Holds information about the companies supplying the products
+- orders: Records customer order details, including dates and customer IDs
+- order_details: Provides line-item details for each order, linking products and quantities
+- employees: Stores employee information
+- shippers: Contains details about shipping companies
 
 The tables are interconnected using foreign keys, allowing for comprehensive data analysis and reporting on sales activities.
 
@@ -24,20 +24,20 @@ Foreign keys are a concept in relational databases, used to establish and enforc
 ## Sample database creation script
 
 <details>
-    <summary>Click to expand</summary>
+    <summary>Select to expand</summary>
 
 ```sql
 CREATE SCHEMA Sales;
 
 CREATE TABLE Sales.Categories
-(      
+(
     CategoryID SERIAL PRIMARY KEY,
     CategoryName VARCHAR(25),
     Description VARCHAR(255)
 );
 
 CREATE TABLE Sales.Customers
-(      
+(
     CustomerID SERIAL PRIMARY KEY,
     CustomerName VARCHAR(50),
     ContactName VARCHAR(50),
@@ -81,8 +81,8 @@ CREATE TABLE Sales.Products(
     CategoryID INTEGER,
     Unit VARCHAR(25),
     Price NUMERIC,
-	FOREIGN KEY (CategoryID) REFERENCES Sales.Categories (CategoryID),
-	FOREIGN KEY (SupplierID) REFERENCES Sales.Suppliers (SupplierID)
+    FOREIGN KEY (CategoryID) REFERENCES Sales.Categories (CategoryID),
+    FOREIGN KEY (SupplierID) REFERENCES Sales.Suppliers (SupplierID)
 );
 
 CREATE TABLE Sales.Orders(
@@ -101,8 +101,8 @@ CREATE TABLE Sales.OrderDetails(
     OrderID INTEGER,
     ProductID INTEGER,
     Quantity INTEGER,
-	FOREIGN KEY (OrderID) REFERENCES Sales.Orders (OrderID),
-	FOREIGN KEY (ProductID) REFERENCES Sales.Products (ProductID)
+    FOREIGN KEY (OrderID) REFERENCES Sales.Orders (OrderID),
+    FOREIGN KEY (ProductID) REFERENCES Sales.Products (ProductID)
 );
 
 INSERT INTO Sales.Categories VALUES(1,'Beverages','Soft drinks, coffees, teas, beers, and ales');
@@ -1044,10 +1044,6 @@ INSERT INTO Sales.OrderDetails VALUES(515,10442,54,80);
 INSERT INTO Sales.OrderDetails VALUES(516,10442,66,60);
 INSERT INTO Sales.OrderDetails VALUES(517,10443,11,6);
 INSERT INTO Sales.OrderDetails VALUES(518,10443,28,12);
-
 ```
-</details>
-
-## Sample database diagram
 
-![Sample Database Schema](../media/sample-database.png)
+</details>

learn-pr/azure-databases/postgresql/basic-sql-join-tables/includes/3-inner-join.md

@@ -1,13 +1,12 @@
-
 ## Join tables
 
-In relational databases, data is frequently organized into multiple tables to minimize redundancy and enhance data integrity. This design approach, known as normalization, avoids repeating the same information in different places. However, this means that useful information is often spread across multiple tables.  
+In relational databases, data is frequently organized into multiple tables to minimize redundancy and enhance data integrity. This design approach, known as normalization, avoids repeating the same information in different places. However, this means that useful information is often spread across multiple tables.
 
-Joins are essential SQL operations that bridge this gap, allowing you to combine rows from two or more tables and retrieve related data in a single, unified result set. In essence, joins enable you to query information that is logically connected but physically separated. They achieve this combination by identifying and matching rows based on values found in one or more common columns between the tables. These common columns often serve as the link between a primary key in one table and a foreign key in another, establishing the relationships defined in the database schema. 
+Joins are essential SQL operations that bridge this gap, allowing you to combine rows from two or more tables and retrieve related data in a single, unified result set. In essence, joins enable you to query information that is logically connected but physically separated. They achieve this combination by identifying and matching rows based on values found in one or more common columns between the tables. These common columns often serve as the link between a primary key in one table and a foreign key in another, establishing the relationships defined in the database schema.
 
-Note: A primary key is a unique identifier for each record in a table, ensuring that no two rows have the same value in this column.  A foreign key, on the other hand, is a column in one table that references the primary key in another table, thereby linking the two tables. 
+Note: A primary key is a unique identifier for each record in a table, ensuring that no two rows have the same value in this column. A foreign key, on the other hand, is a column in one table that references the primary key in another table, thereby linking the two tables.
 
-There are multiple 'flavors' of joins (`INNER`, `LEFT`, `RIGHT`, `FULL OUTER`, `NATURAL`), each designed to combine tables in slightly different ways. They provide control over which rows are included in the result set based on the presence or absence of matching values in the joined tables. 
+There are multiple 'flavors' of joins (`INNER`, `LEFT`, `RIGHT`, `FULL OUTER`, `NATURAL`), each designed to combine tables in slightly different ways. They provide control over which rows are included in the result set based on the presence or absence of matching values in the joined tables.
 
 ## INNER JOIN
 
@@ -16,12 +15,12 @@ An `INNER JOIN` is one of the most commonly used types of SQL joins. It combines
 When performing an `INNER JOIN`, only the rows that satisfy the condition from both tables are included in the result set, effectively filtering out any unmatched data. This makes `INNER JOIN` ideal for retrieving related information where connections between tables are explicitly defined, such as customer orders or employee assignments.
 
 ```sql
-SELECT orders.order_id, customers.customer_name, employees.first_name, employees.last_name 
-FROM sales.orders AS orders 
-INNER JOIN sales.customers AS customers ON orders.customer_id = customers.customer_id 
+SELECT orders.order_id, customers.customer_name, employees.first_name, employees.last_name
+FROM sales.orders AS orders
+INNER JOIN sales.customers AS customers ON orders.customer_id = customers.customer_id
 INNER JOIN sales.employees AS employees ON orders.employee_id = employees.employee_id;
 ```
 
-The provided query employs multiple `INNER JOIN` operations to retrieve a unified result set containing details about `orders`, `customers`, and `employees`.  
+The provided query employs multiple `INNER JOIN` operations to retrieve a unified result set containing details about `orders`, `customers`, and `employees`.
 
-It matches the `customer_id` in the `orders` table with the corresponding `customer_id` in the `customers` table, and the `employee_id` in the `orders` table with the `employee_id` in the `employees` table. As a result, the query outputs each order's ID alongside the names of the customer and employee involved. 
+It matches the `customer_id` in the `orders` table with the corresponding `customer_id` in the `customers` table, and the `employee_id` in the `orders` table with the `employee_id` in the `employees` table. As a result, the query outputs each order's ID alongside the names of the customer and employee involved.

learn-pr/azure-databases/postgresql/basic-sql-join-tables/includes/4-left-right-join.md

@@ -1,9 +1,8 @@
-
 ## LEFT JOIN
 
 A `LEFT JOIN`, also known as a `LEFT OUTER JOIN`, is a type of SQL operation that preserves all the rows from the left-hand (or first) table in the query, regardless of whether there's a matching row in the right-hand (or second) table.
-When a match is found, the columns from the right table are populated with the corresponding values. However, if no match exists, the result includes nulls in the columns originating from the right table. 
-This join is useful when you need to create a comprehensive list from one table while appending related data from another, even when such relationships are incomplete or absent. 
+When a match is found, the columns from the right table are populated with the corresponding values. However, if no match exists, the result includes nulls in the columns originating from the right table.  
+This join is useful when you need to create a comprehensive list from one table while appending related data from another, even when such relationships are incomplete or absent.
 
 ```sql
 SELECT customers.customer_name, orders.order_id
@@ -12,11 +11,11 @@ LEFT JOIN sales.orders AS orders ON customers.customer_id = orders.customer_id;
 ```
 
 The SQL query using a `LEFT JOIN` retrieves all customers from the `sales.customers` table, including those without any matching orders in the `sales.orders` table. The `ON` clause specifies that the `customer_id` field links the two tables.  
-For customers who have placed orders, the `order_id` from the `orders` table is displayed. However, if a customer doesn't have any orders, the result still includes the customer, with the `order_id` column displaying null values.  
+For customers who have placed orders, the `order_id` from the `orders` table is displayed. However, if a customer doesn't have any orders, the result still includes the customer, with the `order_id` column displaying null values.
 
 ## RIGHT JOIN
 
-A `RIGHT JOIN`, also known as a `RIGHT OUTER JOIN`, is an SQL operation that ensures all rows from the right-hand (or second) table are included in the result, regardless of whether there's a matching row in the left-hand (or first) table. 
+A `RIGHT JOIN`, also known as a `RIGHT OUTER JOIN`, is a SQL operation that ensures all rows from the right-hand (or second) table are included in the result, regardless of whether there's a matching row in the left-hand (or first) table.  
 In cases where no match is found, the columns from the left table display null values.
 This type of join is commonly used to focus on the data in the right table while also appending information from the left table wherever relationships exist.
 
@@ -27,4 +26,4 @@ RIGHT JOIN sales.orders AS orders ON customers.customer_id = orders.customer_id;
 ```
 
 This query retrieves all rows from the `sales.orders` table, ensuring that every order is included in the result, even if there's no associated entry in the `sales.customers` table.  
-The `ON` clause specifies the relationship between the two tables via the `customer_id` column. If an order has a corresponding customer, the `customer_name` column is populated with the `customer_name`, null values are displayed for unmatched records.  
+The `ON` clause specifies the relationship between the two tables via the `customer_id` column. If an order has a corresponding customer, the `customer_name` column is populated with the `customer_name`, null values are displayed for unmatched records.

learn-pr/azure-databases/postgresql/basic-sql-join-tables/includes/5-natural-and-full-join.md

@@ -1,7 +1,6 @@
-
 ## FULL OUTER JOIN
 
-A `FULL OUTER JOIN`, also referred to as a `FULL JOIN`, combines the characteristics of both `LEFT JOIN` and `RIGHT JOIN`, including all rows from both tables in the result set. 
+A `FULL OUTER JOIN`, also referred to as a `FULL JOIN`, combines the characteristics of both `LEFT JOIN` and `RIGHT JOIN`, including all rows from both tables in the result set.  
 If there's a matching row between the tables based on the `ON` clause, the columns from both tables are populated. However, if a row in one table doesn't have a match in the other table, the columns from the unmatched table display null values.
 
 ```sql
@@ -19,7 +18,7 @@ You would use this approach for a comprehensive view of all customers and orders
 `NATURAL JOIN` is a type of SQL join that simplifies the process of combining tables by automatically matching columns with the same name and compatible data types from both tables.
 Unlike explicit joins, where the relationship between tables is defined using an `ON` clause, `NATURAL JOIN` relies on column names to identify shared attributes. It ensures that only rows with identical values in the matched columns are included in the result set, effectively filtering out mismatches.
 
-This approach is useful when the tables being joined posses clearly defined relationships and matching column names, as it reduces the need for manual specification of join conditions. 
+This approach is useful when the tables being joined posses clearly defined relationships and matching column names, as it reduces the need for manual specification of join conditions.  
 However, users must exercise caution, as relying purely on column names can lead to unintended results if the tables contain columns with identical names but unrelated data.
 
 ```sql
@@ -28,4 +27,4 @@ FROM sales.customers AS c
 NATURAL JOIN sales.orders AS o;
 ```
 
-This query combines the `sales.customers` and `sales.orders` tables by automatically matching columns with the same name and compatible data types, such as `customer_id`.
+This query combines the `sales.customers` and `sales.orders` tables by automatically matching columns with the same name and compatible data types, such as `customer_id`.