DEV Community: Yash Kishan Singh

Beyond SQL Queries: Exploring the Programming Side of SQL

Yash Kishan Singh — Mon, 29 Jun 2026 14:57:15 +0000

When SQL is mentioned, most people immediately think about retrieving data using SELECT statements. While querying data is one of SQL's primary responsibilities, modern SQL offers much more than simple data retrieval.

Behind many database-driven applications lies a programming layer that allows databases to make decisions, store temporary information, automate repetitive tasks, and execute business logic efficiently. Understanding these programming capabilities transforms SQL from a query language into a powerful development tool.

This article explores some of the fundamental programming concepts available in SQL and explains why they play an important role in building scalable and maintainable database applications.

Why SQL Programming Matters

Modern applications generate and process enormous amounts of data every second. Managing that data isn't limited to inserting, updating, or retrieving records. Business rules, validations, calculations, reporting, and automation often need to happen directly inside the database.

Instead of sending every operation to an application server, SQL programming enables databases to handle many of these tasks efficiently, reducing complexity and improving performance.

Learning these programming concepts provides a stronger understanding of how backend systems interact with databases and how real-world applications manage data at scale.

Variables: Storing Temporary Information

One of the first programming concepts introduced in SQL is the use of variables.

Variables allow temporary information to be stored during the execution of a script. Rather than repeating the same values multiple times throughout a program, data can be stored once and reused whenever needed.

Variables are commonly used to:

Store user inputs
Hold calculation results
Pass parameters into procedures
Retrieve values from database tables
Control program execution

This simple feature significantly improves code readability and makes SQL scripts easier to maintain.

Understanding Batch Execution

A concept that often confuses beginners is batch execution.

A batch is a collection of SQL statements executed together as a single unit.

Understanding batches explains several common programming behaviors:

Variables only exist within the batch where they are declared.
Some database objects must be created in separate batches.
Syntax errors prevent the entire batch from executing.

Learning how SQL processes batches makes debugging much easier and helps developers write more reliable scripts.

Making Decisions with Conditional Logic

Real-world applications constantly make decisions.

Should a customer receive a discount?

Does a product already exist?

Is the stock level below the minimum threshold?

Conditional statements such as IF...ELSE allow SQL programs to answer these questions and execute different logic depending on the outcome.

These programming structures make SQL scripts intelligent instead of simply executing commands sequentially.

Automating Repetitive Tasks with Loops

Not every operation can be completed in a single query.

Sometimes the same process needs to be repeated until a condition is met.

The WHILE loop provides a controlled way to perform repetitive tasks inside SQL programs.

Although SQL generally performs best using set-based operations, understanding loops remains important because many maintenance, migration, and administrative tasks still rely on iterative execution.

Knowing when to use loops—and when not to—is an essential programming skill.

Working with Table Variables

Most variables store only one value.

Table variables extend this idea by temporarily storing multiple rows of structured data during execution.

They become particularly useful when intermediate results need to be processed before producing a final output.

Table variables make SQL programs cleaner by reducing the need for temporary tables while keeping related data together throughout execution.

Combining Programming Concepts

Each feature is useful individually, but the real power of SQL programming becomes clear when these concepts work together.

A typical SQL program might:

Store input values using variables.
Retrieve data from multiple tables.
Apply business rules using conditional statements.
Repeat operations with loops.
Store intermediate results inside table variables.
Return meaningful reports to users.

Combining these building blocks allows databases to perform much more than simple data retrieval—they become capable of supporting complete business workflows.

Practical Learning

Understanding theory is important, but practical implementation is where real learning happens.

Working through programming exercises involving variables, conditional logic, loops, and temporary data structures demonstrates how these concepts solve real database problems.

Each exercise builds confidence and reinforces how different programming constructs interact within larger SQL programs.

Key Takeaways

SQL is far more than a language for writing queries.

Its programming capabilities allow databases to:

Store temporary information efficiently.
Make intelligent decisions.
Automate repetitive processes.
Organize intermediate data.
Support business logic directly within the database.

Mastering these concepts builds a strong foundation for backend development, database administration, and data engineering.

As applications continue to become more data-driven, understanding SQL programming becomes an increasingly valuable skill for every developer.

Final Thoughts

Every technology becomes meaningful when it is applied to solve real problems.

Understanding variables, conditional logic, loops, batch execution, and temporary data structures provides the foundation needed to build reliable database applications.

The journey doesn't end with learning syntax—it begins with designing systems that use these concepts to solve practical business challenges.

Every concept learned and every exercise completed strengthens not only SQL programming knowledge but also the problem-solving skills required in professional software development.

✨📊 🧠 The Ultimate Visual Guide to Large Language Models (LLMs)

Yash Kishan Singh — Fri, 29 May 2026 09:08:51 +0000

Generative AI is a type of artificial intelligence that can produce new content including text, images, audio, and synthetic data. Large Language Models (LLMs) and Generative AI intersect, and they are both a subset of deep learning. But what exactly is an LLM?
At a high level, LLMs refer to large general-purpose language models that can be pre-trained and then fine-tuned for specific purposes. Let's break down exactly what that means.

🧩 Deconstructing "LLM" :

• Large ➡️ This refers to a large training dataset. It also refers to a large number of parameters, which are often called hyperparameters in machine learning. Parameters are basically the memories and the knowledge that the machine learned from the model training. Because of the huge datasets and tremendous number of parameters required, only certain organizations have the capability to train these models.

• General Purpose ➡️ This means the models are sufficient to solve common language problems across industries. This approach works because of the commonality of human language regardless of specific tasks, and it helps overcome resource restrictions.

• Pre-trained & Fine-tuned ➡️ You pre-train a large language model for a general purpose with a large dataset. Then, you fine-tune it for specific aims with a much smaller dataset.

🏆 Why are LLMs a Game Changer?

*The benefits of using large language models are straightforward: *

• A single model can be used for different tasks, including language translation, sentence completion, text classification, and question answering.

• They obtain decent performance even with little domain training data, allowing them to be used in "few-shot" (minimal data) or "zero-shot" scenarios (recognizing things not explicitly taught before).

• The performance of large language models is continuously growing when you add more data and parameters.

⚙️ How They Work: The Transformer Workflow:

• LLMs are almost exclusively based on transformer models. A transformer model consists of two main parts:

• [ Input Sequence ] ➡️ [ Encoder ] {Encodes the input sequence} ➡️ [ Decoder ] {Learns how to decode the representations for a relevant task}

🍦 The 3 Flavors of LLMs:

*There are three main kinds of large language models: *

• Generic Language Models: These predict the next word based on the language in the training data. Think of this model type as an autocomplete in search. For example, if the input is "the cat sat on", the model determines that "the" is most likely the next word.

• Instruction-Tuned Models: This type of model is trained to predict a response to the instructions given in the input. Examples include asking the model to "summarize a text," "generate a poem," or "classify text into neutral, negative, or positive".

• Dialogue-Tuned Models: This model is trained to have a dialogue by the next response. They are a special case of instruction-tuned models where requests are typically framed as questions to a chatbot. They are expected to be in the context of a longer back-and-forth conversation.

📝 The Power of Prompting:

How you talk to an LLM dictates the quality of what you get out of it.

• Prompt Design is the process of creating a prompt tailored to the specific task. For example, if you want a system to translate English to French, the prompt should be in English and specify that the translation should be in French. Prompt design is a general concept and is always essential.

• Prompt Engineering is the process of creating a prompt designed to improve performance. This may involve providing examples of the desired output or using effective keywords. Prompt engineering is a more specialized concept, only necessary for systems requiring high accuracy or performance.
Pro-Tip: Utilize Chain of Thought reasoning. This is the observation that models are better at getting the right answer when they first output text that explains the reason for the answer.

🛠️ Customizing Your AI: Tuning Workflows

A model that can do everything has practical limitations, but task-specific tuning can make LLMs more reliable.
[ Base Foundation Model ] ➡️ [ Domain Adaptation ] {e.g., Vertex AI tuning models specifically for legal or medical domains}.
If you need deeper customization, you have two distinct paths:

Fine-Tuning: Bring your own dataset and retrain the model by tuning every weight in the LLM.

The Catch: This requires a big training job and hosting your own fine-tuned model, which is expensive and often unrealistic.
Parameter-Efficient Tuning Methods (PETM): Tune a large language model on your own custom data without duplicating the model.

The Benefit: The base model itself is not altered. Instead, a small number of add-on layers are tuned, which can be swapped in and out at inference time.

☁️ Building with Google Cloud:

*If you want to move from theory to building, Google Cloud provides several powerful tools: *

• Vertex AI Studio: Helps developers quickly explore, customize, and deploy generative AI models. It provides a library of pre-trained models, fine-tuning tools, and a community forum.

• Vertex AI Agent Builder: Build chatbots, custom search engines, and digital assistants with little or no coding and no prior machine learning experience.

• Gemini: A multimodal AI model that is incredibly adaptable and scalable. Unlike traditional language models, Gemini is not
limited to text; it can analyze images, understand audio nuances, and interpret programming code.

• Model Garden: A resource that is continuously updated to include new models.

🚀 Introduction to Generative AI: A Complete Visual Guide (For Techies & Beginners Alike)

Yash Kishan Singh — Sun, 24 May 2026 09:16:08 +0000

Have you ever wondered how tools like ChatGPT, Claude, Gemini and many more ai can write code in seconds, or how AI models can instantly paint a digital masterpiece from a simple text prompt?

The magic behind this is Generative AI (GenAI)—a cutting-edge branch of Artificial Intelligence capable of producing entirely new content, including text, imagery, audio, and synthetic data.

Generative AI (GenAI) is shifting computing from analyzing existing data to creating completely new content. Skip the dense textbooks—here is the blueprint of how it works.

1. The Technology Landscape: Where Does GenAI Fit? 🌍

Artificial Intelligence is organized in nesting layers. GenAI represents the innermost specialized core.

2. Core Learning Mechanics

Machine learning models map information using two distinct methodologies:

A. Supervised Learning (Labeled Data)
Trains on tagged examples to calculate future values.

The Workflow:
[Input Data (x)] ➡️ [Model] ➡️ [Prediction of output (ŷ)] ➡️ [Compare with Expected Output] ➡️ Calculate Error ➡️ [Update Model]

B. Unsupervised Learning
What it is: The model is given unlabeled data (no tags) and must discover hidden patterns on its own.

Example: Grouping/clustering employees based on tenure and income to see who is on a "fast track."

The Workflow:
Input Data (x) ➡️ Model ➡️ Discover Patterns ➡️ Generate Clusters/Examples

Note on Deep Learning: Deep Learning models can handle both methods. They can also use Semi-Supervised Learning, where a model is trained on a tiny amount of labeled data and a massive amount of unlabeled data.

3. Discriminative vs. Generative Models 🥊

When dealing with Deep Learning and Machine Learning, models generally fall into two categories:

4. The GenAI Litmus Test: Is it GenAI or Not? 🧐

You can mathematically verify if an application uses GenAI via the function:

y = f(x)
Where x = input data, f = system model, and y = output

5. Traditional ML vs. The Robust GenAI Process

Generative AI is far more robust and flexible than traditional machine learning setups:

Traditional Supervised ML Process:
[Training Code] + [Labeled Data] ➡️ Model Building ➡️ Output: Predict / Classify / Cluster
(Highly specific; usually only does one task well).

Generative AI Process:
[Training Code] + [Labeled Data] + [Unlabeled Data] ➡️ Foundation Model ➡️ Output: Text, Code, Images, Audio, Video, etc.
(Massively scalable; can handle a variety of downstream tasks).

6. Under the Hood: Transformers, Prompts, & Hallucinations 🪄

The Power of Transformers
Modern generative AI, which ignited the 2018 revolution with the introduction of Transformers, relies on paired neural networks to process context and construct responses. A transformer model consists of two key components:

Encoder: Encodes the input text into a mathematical representation.

Decoder: Decodes that representation to generate the final task output.
For Example: "How's it going?" ➡️ [ Encoder 🧠 ] ➡️ [ Decoder 💬 ] ➡️ "I'm doing alright, thanks for asking!"

The_Workflow

Key AI Terminology to Know:

✍️ Prompt: A short piece of text given to a Large Language Model (LLM) as input to control and guide its output.
😵 Hallucination: A flaw where the AI model generates incorrect, nonsensical, or completely misleading information that sounds convincing.

7. The Exploding Universe of Modalities 🚀

Generative AI models are categorized by their modalities—the types of data they accept as input and produce as output:

Text-to-Text: Takes natural language input --> produces text output (e.g., LLMs).
Text-to-Image: Uses techniques like Diffusion to transform random noise into crisp, realistic images based on your description.
Text-to-Video: Aims to generate a moving video representation from a simple text input.
Text-to-3D: Generates 3D objects corresponding to user text descriptions for use in games and virtual worlds.

🌟 The Big Picture: Foundation Models:

Foundation layers adapt dynamic input parameters to perform tasks across distinct modes:

- Conclusion

Generative AI represents a massive change. It turns computers from simple data tools into creative partners that help people make new things. Whether you are a programmer or a casual user, understanding this technology is the key to readying yourself for the future.