* A view is a virtual table based on the result set of a query.
* Views allow you to encapsulate complex queries (including joins and calculated columns) and make them reusable by other users.
* Index improves performance but does not store or rerun queries.
* Scalar function returns a single value, not a tabular result.
* Table stores raw data, not queries.
Reference: Create views in SQL Server

Explanation:
You have 1,000 untagged images and want to retrain the Custom Vision model as quickly as possible. The key is to avoid manually tagging every image, since that is time-consuming.
Step 1: Upload all the images
* First, bulk upload all the untagged images into the Custom Vision project.
* At this stage, they will have no labels.
Step 2: Get suggested tags
* The Custom Vision portal offers an auto-suggest feature that uses the current trained model to predict tags for new, untagged images.
* This dramatically reduces manual tagging effort.
Step 3: Review the suggestions and confirm the tags
* Auto-suggestions are not always 100% accurate, so you must confirm or correct them.
* Once confirmed, the dataset is labeled properly and ready for retraining.
Why not the other options?
* Upload the images by category / group into category folders: This is only helpful if the images already have known categories, but here they arrive untagged.
* Tag the images manually: This would take much longer and contradicts the requirement to minimize time.
* Upload all the images.
* Get suggested tags.
* Review the suggestions and confirm the tags.
* Custom Vision - Tag images
* Custom Vision - Suggested tags with predictions

The method shown uses the Read API of the Azure Computer Vision client library. The ReadAsync call submits the OCR job and returns an Operation-Location header, which contains the operationId. Then GetReadResultAsync(Guid.Parse(operationId)) is called to fetch the result.
* The Read API is asynchronous.
* Submitting the read request does not mean the OCR has finished.
* If you immediately call GetReadResultAsync, the operation may still be in progress, resulting in incomplete or empty results.
* Check the results.Status property
* The response from GetReadResultAsync includes a status property.
* Possible values: notStarted, running, succeeded, failed.
* You must wait until the status is succeeded before processing results.
* This ensures you don't attempt to read lines before OCR has completed.
* This corresponds to B.
* Wrap in a loop with delay
* Since OCR takes time, you need to poll the service until the status becomes succeeded or failed.
* A typical pattern is:
* ReadOperationResult results;
* do
* {
* results = await client.GetReadResultAsync(Guid.Parse(operationId));
* await Task.Delay(1000); // wait 1 second before retrying
* }
* while (results.Status == OperationStatusCodes.Running || results.Status == OperationStatusCodes.
NotStarted);
* This corresponds to D.
* A. Remove the Guid.Parse(operationId) parameter
* Incorrect. The operationId is required to fetch the OCR results.
* B. Add code to verify the results.Status value
* Correct. You must check whether the operation has completed.
* C. Add code to verify the status of the txtHeaders.Status value
* Incorrect. txtHeaders only contains metadata and the operation location. The OCR completion status comes from the results.Status in the GetReadResultAsync response, not from txtHeaders.
* D. Wrap the call to GetReadResultAsync within a loop that contains a delay
* Correct. This is how you poll until the operation has finished.
The answer: B and D
* Azure Computer Vision Read API
* Read text using the Computer Vision client library

Explanation:
You are deploying Anomaly Detector API as a container. The key requirements are:
* Prevent billing and API keys from being exposed in command-line history.
* Control access to container images using Azure RBAC.
Step-by-step reasoning:
* Pull the Anomaly Detector container image
* Microsoft Cognitive Services (including Anomaly Detector) provides container images via Microsoft Container Registry.
* You must first pull the container image locally.
* Push the image to an Azure container registry (ACR)
* To enforce Azure RBAC, you need to use Azure Container Registry instead of Docker Hub.
* Storing in ACR ensures authentication and role-based access control to the image.
* Distribute a docker run script
* Instead of providing credentials directly on the command line (which risks storing API keys in shell history), best practice is to distribute a docker run script (or use environment variables / mounted files) to run the container.
* This prevents exposure of sensitive information.
* Run the container on local devices or on-premises datacenters
* The container now runs securely, with API key and billing info injected at runtime via environment variables or mounted secrets.
* Create a custom Dockerfile # Not needed, because Microsoft provides the official Anomaly Detector container image.
* Build the image # Not required; again, the container is prebuilt.
* Push the image to Docker Hub # Does not allow RBAC, so this would not meet the security requirement.
Correct Sequence:
* Pull the Anomaly Detector container image.
* Push the image to an Azure container registry.
* Distribute a docker run script.
* Run the container in the local or on-prem environment.
* Use Cognitive Services containers
* Azure Container Registry - Authentication and RBAC
* Best practices for running Cognitive Services containers

* The requirement: A chatbot that answers based on a product knowledgebase (multiple PDFs).
* Best choice: Custom Question Answering in Azure AI Language.
* It allows you to ingest documents like PDFs, FAQs, manuals.
* Minimal development effort since you just upload documents and the service automatically indexes them.
* Other options:
* CLU # for intent/intent-based classification, not for knowledgebases.
* Language detection # only detects language, not Q&A.
* Azure OpenAI # could work, but more costly and requires prompt engineering (not the
"minimize effort/cost" requirement).
Microsoft Reference:
Custom question answering in Azure AI Language