pull base content,head:MicrosoftDocs:main,into:wwlpublishsync

Author: wwlpublish

learn-pr/advocates/challenge-github-copilot-sql/1-introduction-github-copilot-codespaces.yml

@@ -0,0 +1,13 @@
+### YamlMime:ModuleUnit
+uid: learn.challenge-github-copilot-with-sql.introduction-github-copilot-codespaces
+title: Introduction to GitHub Copilot in GitHub Codespaces
+metadata:
+  title: Introduction to GitHub Copilot in GitHub Codespaces
+  description: Learn how to use GitHub Copilot in GitHub Codespaces to enhance your coding experience.
+  ms.date: 06/25/2025
+  author: Orin-Thomas
+  ms.author: orthomas
+  ms.topic: unit 
+durationInMinutes: 7
+content: |
+  [!include[](includes/1-introduction-github-copilot-codespaces.md)]

learn-pr/advocates/challenge-github-copilot-sql/2-work-with-sql-using-github-copilot.yml

@@ -0,0 +1,13 @@
+### YamlMime:ModuleUnit
+uid: learn.challenge-github-copilot-with-sql.work-with-sql-using-github-copilot
+title: Work with SQL using GitHub Copilot
+metadata:
+  title: Work With SQL Using GitHub Copilot
+  description: Learn how to leverage GitHub Copilot to write and optimize SQL queries more efficiently.
+  ms.date: 06/25/2025
+  author: Orin-Thomas
+  ms.author: orthomas
+  ms.topic: unit
+durationInMinutes: 11
+content: |
+  [!include[](includes/2-work-with-sql-using-github-copilot.md)]

learn-pr/advocates/challenge-github-copilot-sql/3-github-skills-exercise.yml

@@ -0,0 +1,13 @@
+### YamlMime:ModuleUnit
+uid: learn.challenge-github-copilot-with-sql.github-skills-exercise
+title: Hands-on exercise - Challenging GitHub Copilot with SQL
+metadata:
+  title: Hands-on exercise - Challenging GitHub Copilot with SQL
+  description: Learn how to apply advanced GitHub Copilot features to interact with an application that uses complex SQL queries.
+  ms.date: 06/25/2025
+  author: Orin-Thomas
+  ms.author: orthomas
+  ms.topic: unit 
+durationInMinutes: 3
+content: |
+  [!include[](includes/3-github-skills-exercise.md)]

learn-pr/advocates/challenge-github-copilot-sql/4-knowledge-check.yml

@@ -0,0 +1,47 @@
+### YamlMime:ModuleUnit
+uid: learn.challenge-github-copilot-with-sql.knowledge-check
+title: Knowledge check
+metadata:
+  title: Knowledge Check
+  description: Check your knowledge.
+  ms.date: 06/25/2025
+  author: Orin-Thomas
+  ms.author: orthomas
+  ms.topic: unit 
+durationInMinutes: 3
+content: Choose the best response for each question. 
+quiz:
+  questions:
+    - content: "How can GitHub Copilot assist in optimizing SQL queries within a GitHub Codespace environment?"
+      choices:
+        - content: "By providing general coding tips and tricks."
+          isCorrect: false
+          explanation: "General coding tips don't address SQL query optimization."
+        - content: "By suggesting specific optimizations for slow or inefficient queries."
+          isCorrect: true
+          explanation: "GitHub Copilot can analyze SQL queries and suggest optimizations such as removing unnecessary JOINs, optimizing SELECT DISTINCT, or refactoring subqueries."
+        - content: "By automatically rewriting all SQL queries without user input."
+          isCorrect: false
+          explanation: "GitHub Copilot requires user input to provide specific suggestions and doesn't automatically rewrite all queries."
+    - content: "What is the role of GitHub Copilot in generating SQL-based tests or assertions?"
+      choices:
+        - content: "It can suggest appropriate testing frameworks based on the project type."
+          isCorrect: true
+          explanation: "GitHub Copilot can help generate SQL-based tests or assertions to verify query results or database state and suggest appropriate testing frameworks based on the project type."
+        - content: "It can execute SQL tests automatically without user intervention."
+          isCorrect: false
+          explanation: "GitHub Copilot assists in generating tests but doesn't execute them automatically."
+        - content: "It can only generate unit tests for non-SQL code."
+          isCorrect: false
+          explanation: "GitHub Copilot can generate tests for SQL code as well as other types of code."
+    - content: "How can GitHub Copilot enhance the understanding of complex SQL queries?"
+      choices:
+        - content: "By providing detailed documentation for the entire codebase."
+          isCorrect: false
+          explanation: "While GitHub Copilot can generate documentation, the specific enhancement for understanding SQL queries comes from its ability to explain to them."
+        - content: "By explaining the logic and structure of complex SQL queries."
+          isCorrect: true
+          explanation: "GitHub Copilot can explain complex SQL queries to help users understand their logic and structure."
+        - content: "By rewriting SQL queries to make them simpler."
+          isCorrect: false
+          explanation: "Rewriting queries is related to optimization and refactoring, but doesn't increase understanding of query functionality."

learn-pr/advocates/challenge-github-copilot-sql/5-summary.yml

@@ -0,0 +1,13 @@
+### YamlMime:ModuleUnit
+uid: learn.challenge-github-copilot-with-sql.summary
+title: Summary
+metadata:
+  title: Summary
+  description: Summary of the module.
+  ms.date: 06/25/2025
+  author: Orin-Thomas
+  ms.author: orthomas
+  ms.topic: unit
+durationInMinutes: 1
+content: |
+  [!include[](includes/5-summary.md)]

learn-pr/advocates/challenge-github-copilot-sql/includes/1-introduction-github-copilot-codespaces.md

@@ -0,0 +1,62 @@
+GitHub Copilot is an AI pair programmer that helps you write code faster and with less effort. Copilot works alongside you directly in your code editor, seamlessly integrating AI into your workflow. It provides intelligent code suggestions and completions based on the context of your code, helping you write code more efficiently and accurately. 
+
+General support features:
+
+- Language Support: Supports multiple programming languages and frameworks, adapting to the code you're working on.
+- IDE Integration: Works directly in your code editor, providing suggestions and completions as you write code. Is available within the GitHub Codespaces environment.
+
+GitHub Copilot's autocomplete features:
+
+- Code line completions and suggestions are based on the context of your code.
+- Suggestions can be single lines of code, entire functions, or even entire classes.
+
+Copilot suggestions can help you write code faster and with fewer errors, improving your productivity and efficiency.
+
+GitHub Copilot Chat's AI assistance features include:
+
+- Chat Interface: Provides a chat interface for interacting with GitHub Copilot, asking and receiving answers to coding-related questions.
+- Code Explanation: Provides explanations for selected code snippets, helping you understand syntax, programming concepts, test cases, debugging, and more, without requiring you to navigate documentation or search online forums.
+- Documentation Generation: Generates explanations or documentation for selected code or entire workspaces, helping you understand and document your codebase.
+- Test Case Generation: Helps in generating test cases for your code, saving time, and improving code quality.
+- Code fixes: Provides suggestions for refactoring code and fixing common issues, improving code quality and maintainability.
+
+By using AI to assist with coding tasks, GitHub Copilot can help you focus on higher-level design and problem-solving, rather than getting bogged down in syntax and implementation details.
+
+## Understand GitHub Codespaces
+
+GitHub Codespaces provides a cloud hosted development environment, ready to use and accessible from any computer with an internet connection and standards compliant web browser. You use GitHub Codespaces within your browser and when a codespace is loaded, you interact with it as you would any traditional IDE. GitHub Codespaces provides you with an environment that includes all the essential languages, tools, and utilities you need to code effectively. 
+
+![A screenshot of the GitHub Codespace interface, showing the explorer, a readme file, and the Ask Copilot pane.](../media/codespace-interface.svg)
+
+You can also use the terminal pane within a GitHub Codespace to run commands, such as python scripts.
+
+![A screenshot showing a python script being called from a GitHub codespace.](../media/run-python-terminal.svg)
+
+## Create a GitHub Codespace
+
+To begin developing using GitHub Codespaces, you can create a codespace from a template or from any branch or commit in a GitHub repository. When you create a codespace from a template, you can start from a blank template or choose a template suitable for the work you're doing.
+
+For example, you can:
+
+- Create a codespace from your GitHub repository.
+- Push code from the codespace to your GitHub repository.
+- Use VS Code to develop code within the codespace.
+- Customize the codespace with custom images.
+
+To open a codespace from your GitHub account, start at the landing page of your repository, choose the Code button, and then choose Create codespace on the repository on the Codespaces tab.
+
+![A screenshot showing how to open a GitHub Codespace from a GitHub repository.](../media/open-codespace-repository.svg)
+
+## Customize GitHub Codespaces
+
+You can customize your project for GitHub Codespaces by committing configuration files to your repository (also known as configuration-as-code), which creates a repeatable codespace configuration for all users of your project. Each codespace you create is hosted by GitHub in a Docker container that runs on a virtual machine. You can choose the type of virtual machine you want to use depending on the resources you need.
+
+You can configure the development container for a repository so that any codespace created for that repository gives you a tailored development environment, complete with all the tools and runtimes you need to work on a specific project. A development container file is a JSON file that lets you customize the default container image that runs your codespace. You can use this JSON file to configure VS Code settings, run custom code, manage network traffic port forwarding, and configure other settings. 
+
+## GitHub Copilot in GitHub Codespaces
+
+One of the tools you can use within a GitHub Codespace is GitHub Copilot.  You can verify that GitHub Copilot and Copilot Chat are available in your GitHub Codespaces environment by checking the Extensions tab and searching for GitHub Copilot and choosing the Install option if GitHub Copilot isn't already present.
+
+![A screenshot of the Extensions pane showing the GitHub Copilot extension.](../media/install-copilot.svg)
+
+You can use the GitHub Copilot icon to open the Copilot Chat panel. You can use the chat panel to interact with code and other artifacts within the GitHub Codespace interface.

learn-pr/advocates/challenge-github-copilot-sql/includes/2-work-with-sql-using-github-copilot.md

@@ -0,0 +1,93 @@
+GitHub Copilot can be used to interact with all types of code, this includes interacting with popular programing languages and providing you with the option of writing, debugging, and optimizing SQL code.
+
+GitHub Copilot can perform the following tasks related to SQL code:
+
+- Query Explanation: Use Copilot to explain complex SQL queries to better understand their logic and structure.
+- Query Optimization: Ask Copilot for suggestions to optimize slow or inefficient queries, such as removing unnecessary JOINs, optimizing SELECT DISTINCT, or refactoring subqueries.
+- Query Refactoring: Request Copilot to rewrite queries for better readability or maintainability, e.g., replacing CROSS JOINs or simplifying nested queries.
+- Generating Queries: Have Copilot generate new SQL queries based on your data requirements, such as SELECT, INSERT, UPDATE, or DELETE statements.
+- Data Validation: Use Copilot to help write SQL queries that validate data integrity or check for specific conditions in your database.
+- Schema Exploration: Ask Copilot to help you write queries that explore or document your database schema (e.g., listing tables, columns, or relationships).
+- Test Generation: Request Copilot to generate SQL-based tests or assertions to verify query results or database state.
+- Error Debugging: Ask Copilot to help debug SQL errors or suggest fixes for common issues (e.g., syntax errors, missing indexes).
+- Prompt Creation: Have Copilot generate prompts or templates for creating high-performing queries from scratch.
+
+GitHub Copilot provides better outcomes when your prompts are more specific. If you provide general prompts, you're likely to receive general answers. If you provide more detail in your prompts and ask more detailed questions, you're more likely to get detailed answers.
+
+For example, you could use GitHub Copilot to provide you with the SQL code to create a table that included columns for first name, last name, date of birth, favorite movie, and pet name by issuing the following prompt:
+
+_@workspace Please provide me with the SQL code to create a table that included columns for first name, last name, date of birth, favorite movie and pet name_
+
+![A screenshot a GitHub Copilot prompt related to the creation of a table in SQL.](../media/create-table.svg)
+
+## Understand an application that includes SQL
+
+For example, if you opened a codespace were presented with an application that included SQL code, you could query GitHub Copilot with the following prompt to understand more about the project in the following manner:
+
+_@workspace Please briefly explain the structure of this project.
+What should I do to run it?_
+
+![A screenshot showing GitHub Copilot's response to a query about project structure.](../media/project-structure.svg)
+
+## Understand SQL code
+
+You can use the /explain prompt to understand specific code. For example, a project might contain a file named complex.sql, which contains the query that is being executed in the application. To understand the contents of complex.sql, you can select it within the Explorer pane of GitHub Codespaces and then use the /explain prompt in the chat.
+
+![A screenshot of a computer screen  AI-generated content may be incorrect.](../media/examine-sql.svg)
+
+Rather than selecting the whole file, you're able to select sections of the code and ask GitHub Copilot to provide a detail about those sections. 
+
+## Optimize and refactor SQL queries
+
+Sometimes you're presented with queries that are slow or inefficient because there are unnecessary JOINS, tables queried don't have indexes or contain redundant nested subqueries. Using GitHub Copilot, you can select a query and prompt for any optimizations that may improve performance.
+
+Similarly, you can request Copilot to rewrite queries for better readability or maintainability, asking Copilot to provide comments to explain functionality for future developers who may need to review the code.
+
+An example prompt might be:
+
+_"Add detailed comments to the complex.sql file explaining the purpose and functionality of each CTE, SQL clause, and calculation. Make sure to describe what each section of the query does, including how the year is extracted, how the rolling average is computed, the logic behind the performance ratio, and the meaning of each CASE statement. The comments should make it easy for someone unfamiliar with the file to understand the logic and intent of the entire query."_
+
+## Validate integrity of data
+
+Use Copilot to help write SQL queries that validate data integrity or check for specific conditions in your database. For example, you could prompt GitHub Copilot to perform one of the four types of integrity checks:
+
+- Uniqueness / duplicate checks
+- Referential integrity (foreign key violations)
+- Domain integrity (values within expected ranges)
+- Business rule checks (custom logic violations)
+
+An example query might be:
+
+_"Write a SQL query that checks for orphaned foreign keys between Orders and Customers tables."_
+
+## Database schema documentation
+
+You can ask GitHub Copilot to help you write queries that explore or document your database schema. By giving GitHub Copilot the context of the database you're working with, you'll be able to determine whether the code that interacts with that database can be optimized. While GitHub Copilot doesn't deeply analyze the execution plans of queries, but understanding the context of the SQL database you're interacting with, it can provide better advice.
+
+## SQL test generation
+
+You can request that GitHub Copilot to generate SQL-based tests or assertions to verify query results or database state. Copilot can suggest appropriate testing frameworks based on your project type. To configure your testing environment, enter the /setupTests command in the chat input field and follow GitHub Copilot's guidance to configure your project.
+
+GitHub Copilot can help you write tests for your application code by generating test code that covers your codebase. This includes unit tests, end-to-end tests, and tests for edge cases.
+
+## Debug SQL errors
+
+You can ask GitHub Copilot to help debug SQL errors or suggest fixes for common issues. For example, you can select a file or block of code and ask GitHub Copilot to locate and correct any syntax errors.  
+
+By having GitHub Copilot provide you with full table schema and indexes, you can then have GitHub Copilot generate representative queries against the tables and suggest any additional indexes, which might improve performance.
+
+## GitHub Copilot prompt creation
+
+You can use GitHub Copilot to generate prompts to create code that performs better than existing code. When interacting with GitHub Copilot, provide as much detail in the question as possible to increase the chance that the answer provided meets your requirements. To accomplish this:
+
+- Have an understanding of the code. This understanding can be derived from existing interaction with GitHub Copilot.
+- Select the original code and open GitHub Copilot Chat.
+- Provide as much detail as possible. For example, you might provide GitHub Copilot chat with the following prompt:
+
+_Given the following requirements:_
+_The database is SQLite and contains tables relevant to movie ratings (see the structure in complex.sql)._
+_The query should efficiently aggregate and return the top-rated movies by region, minimizing execution time and avoiding unnecessary operations (such as redundant CASTs, unnecessary JOINs, or SELECT DISTINCT if not needed)._
+_The result should include movie title, average rating, region, and any other relevant fields._
+_The query must complete in under 1.5 seconds on a large dataset.
+All business logic and correctness must be preserved as in the original complex.sql._
+_Write a high-performance SQL query that fulfills these requirements, and explain any optimizations you apply._