---
title: "Cómo crear un stored procedure en Microsoft SQL Server"
slug: "creating-a-stored-procedure-in-microsoft-sql-server"
published_at: "2023-08-07T04:17:09.000Z"
categories: "SQL Avanzado, Transact-SQL"
---

# Cómo crear un stored procedure en Microsoft SQL Server

> Cómo crear un Stored Procedure en Microsoft SQL Server

![](/blog/creating-a-stored-procedure-in-microsoft-sql-server/image-18-1024x376.png)

## ¿Qué es un stored procedure?

Antes que nada, digamos que siempre tenés que hacer la misma consulta y ya estás cansado de hacer una y otra vez lo mismo.

Por suerte para vos, casi todos los servidores SQL tienen una solución.

La solución se llama stored procedures, que son rutinas que se guardan en la base de datos. La forma en que hacemos esto y la forma en que ejecutamos las rutinas puede variar de un intérprete SQL a otro (por ejemplo, algunos usan EXEC como SQL Server, y otros usan CALL para ejecutar la rutina que guardaste).

## Preparando nuestra base de datos para las pruebas

Bueno, basta de charla, pongamos manos a la obra. Antes que nada, vas a necesitar tener tu entorno creado. Ya hablamos de esto [en este post](/es/sql-server-installation). También vas a necesitar [este post](/es/install-ssms-sql-server-quick-guide) para poder ejecutar comandos en tu nueva y hermosa instalación de SQL Server.

Después de hacer esto vamos a usar **SSMS SQL Server** y crear una nueva base de datos (haciendo clic en Databases – New Databases)

![](/blog/creating-a-stored-procedure-in-microsoft-sql-server/image.png)

Yo la creo con el nombre **“test”**, pero vos podés ponerle lo que quieras.

La base de datos va a aparecer en tu panel izquierdo, ahora tenés que hacer clic en ella y **crear una tabla**

![](/blog/creating-a-stored-procedure-in-microsoft-sql-server/image-1.png)

Mi tabla tiene tres columnas, name (varchar (30)), surname (varchar (40)) y number (int)

Una vez que creaste tu tabla (**en mi caso también se llama test**), podemos continuar con el tutorial.

## Creando nuestro primer Stored Procedure – Insertando nuevos registros

Ahora vamos a crear nuestro primer stored procedure, hacé clic derecho en tu base de datos y hacé clic en **“new query”**

![](/blog/creating-a-stored-procedure-in-microsoft-sql-server/image-2.png)

Empecemos agregando personas a esta tabla que creamos con un stored procedure.

```sql
CREATE PROCEDURE dbo.add_people (
	@firstname varchar(30),
	@lastname varchar(40),
	@number int)
	AS
	SET NOCOUNT ON;
	INSERT INTO dbo.test (name,surname,number)
	VALUES (@firstname,@lastname,@number);
```

Bien, veamos qué hicimos acá.

Antes que nada, creamos nuestro procedimiento llamado dbo.add_people con tres parámetros. Estos parámetros van a ser consistentes con nuestra tabla.

SET NOCOUNT ON es una línea que evita que el procedimiento cuente las filas.

Después de esto, vamos a hacer nuestra consulta como la haríamos fuera del procedimiento, pero la diferencia es que vamos a poner nuestros parámetros como los valores que vamos a insertar.

Ahora para ejecutarlo:

```sql
EXEC dbo.add_people 'John', 'Doe',0;
```

Esto va a agregar personas a nuestra tabla usando un stored procedure.

## Otro ejemplo – Actualizando con un stored procedure

Ahora digamos que tenés que cambiar el valor de number de un usuario.

¡Hagámoslo con otro procedimiento!

```sql
CREATE PROCEDURE dbo.change_number (
	@firstname varchar(30),
	@lastname varchar(40),
	@number int)
	AS
	SET NOCOUNT ON;
	UPDATE dbo.test set number=@number
	WHERE name=@firstname and surname=@lastname;
```

Y para ejecutarlo

```sql
EXEC dbo.change_number 'John', 'Doe', 10;
```

## Listando personas con un stored procedure

Ya debés estar viendo algunas similitudes, ahora listemos todos los registros que empiezan con J y cuyo apellido empieza con D

```sql
CREATE PROCEDURE dbo.list_by_like (
	@firstname varchar(30),
	@lastname varchar(40))
	AS
	SET NOCOUNT ON;
	SELECT * FROM dbo.test WHERE name LIKE '%'+@firstname+'%' and surname LIKE '%'+@lastname+'%';
```

Y ejecutémoslo:

```sql
EXEC dbo.list_by_like 'J', 'D';
```

## Más complejo – WHILE dentro de un stored procedure y armando nuestra query dentro del stored procedure

Bien, hasta ahora vimos cómo hacer un stored procedure simple ¿PERO qué pasa con uno más complejo? Digamos que tenemos un solo parámetro, ”J,D” y queremos dividirlo y encontrar los registros que coincidan (usando J para el nombre y D para el apellido)

```sql
CREATE PROCEDURE dbo.listing_with_one_parameter (
@param varchar(30))
AS
SET NOCOUNT ON;
BEGIN
DECLARE @sql_string nvarchar(200);
DECLARE @n int;
DECLARE @p int;
DECLARE @gname nvarchar(10);
DECLARE @glastname nvarchar(10);
SET @n=(SELECT COUNT(*) FROM STRING_SPLIT(@param,','));
SET @p=0;
	WHILE @p < @n
	BEGIN
		IF @p=0
		BEGIN
			SET @gname = '%'+SUBSTRING(@param, 0, CHARINDEX(',',@param,0))+'%';

		END;
		IF @p=1
		BEGIN
			SET @glastname='%'+SUBSTRING(@param, CHARINDEX(',',@param,0)+1, LEN(@param))+'%'; 
		END;
		SET @p=@p+1;
	END;
	SET @sql_string = 'SELECT * FROM dbo.test WHERE name LIKE @name AND surname LIKE @surname';
	EXECUTE sp_executesql @sql_string, N'@name nvarchar(10),@surname nvarchar(10)', @gname, @glastname;

END;
```

Bien, veamos qué hicimos acá…

Primero declaramos nuestras variables dentro de nuestro procedimiento, vamos a usar algunas para contar y otras para armar nuestra consulta.

Como estamos usando WHILE e IF en nuestro procedimiento, deberíamos establecer los límites de cada sección usando BEGIN y END;

Vamos a setear la variable @n como una consulta sobre nuestro param (bueno, esto es un poco complicado, pero para resumirlo, estamos contando en cuántas partes se va a dividir el param si usamos ‘,’ como delimitador).

Después vamos a entrar en un bucle while usando @p como contador y @n como nuestro número tope.

Si @p es 0 entonces vamos a usar la primera parte del parámetro como el nombre, la vamos a envolver con ‘%’ antes y después de esa parte del parámetro (esto es porque vamos a usar un LIKE en la última consulta).

Si @p es 1 entonces vamos a usar la segunda parte del parámetro como el apellido, también la vamos a envolver con ‘%’.

Por último, vamos a armar nuestra consulta y vamos a usar un truco, un procedimiento incorporado de SQL Server que convierte un string en una sentencia SQL. Este procedimiento incorporado se llama sp_executesql y en él, tenemos que declarar nuestra consulta como el primer parámetro, y vamos a tener que declarar nuestras variables indicando cuál de nuestras variables es cada una de ellas (cada parámetro del procedimiento tiene que ser un nvarchar, podemos declarar cualquier tipo de variable dentro de él).

¡Ahora ejecutémoslo!

```sql
EXEC dbo.listing_with_one_parameter 'J,D'
```

![](/blog/creating-a-stored-procedure-in-microsoft-sql-server/image-3.png)

Este sería nuestro resultado.

## Conclusión

Ya vimos con más detalle cómo usar stored procedures en Microsoft SQL Server.

Podés encontrar más información sobre esto en la [documentación de Microsoft SQL Server](https://learn.microsoft.com/en-us/sql/database-engine/log-shipping/log-shipping-tables-and-stored-procedures?view=sql-server-ver16).

También hice otro post sobre stored procedures donde los comparo con los stored procedures de PLSQL, ¡podés verlo [acá](/es/how-to-use-parameters-in-stored-procedures)!

¡Nos vemos en el próximo post!