Archivo

Archive for the ‘Transact-SQL’ Category

Variables y tipos de datos

6 abril 2013 1 comentario

En SQL Server, cada columna, variable local, expresión y parámetro tiene un tipo de datos relacionado. Un tipo de datos es un atributo que especifica el tipo de datos que el objeto puede contener: datos de enteros, datos de caracteres, datos de moneda, datos de fecha y hora, cadenas binarias, etc.

SQL Server proporciona un conjunto de tipos de datos del sistema que define todos los tipos de datos que pueden utilizarse con SQL Server. También puede definir sus propios tipos de datos en Transact-SQL o Microsoft .NET Framework.

Declarar una variable

Una variable es un área de memoria utilizada para almacenar valores que pueden ser utilizados en un programa.

Antes de utilizar una variable, se debe informar a la intérprete. Esto también se refiere a como se declara una variable. Para declarar una variable, utilice la palabra clave DECLARE aplicando la siguiente fórmula:

001 Variables and Data Types

Hay reglas y sugerencias que se va a utilizar para los nombres :

- Un nombre puede empezar con un guión o una carta.

Algunos ejemplos son @ _n, @act, o la @Segundo

- Después de que el primer carácter como un carácter de subrayado o una letra, el nombre  tendrá combinaciones de relieve, las letras y dígitos.

Algunos ejemplos  @_n24  o @act_52_t

- Un nombre no incluir caracteres especiales como!, @, #, $,%, ^, &, O *
-  Si el nombre es una combinación de palabras, cada palabra comenzará en mayúsculas. Algunos ejemplos  @ FechaContratación, @ _JuegoReal, o @NumeroLicencia

002 Variables and Data Types

Leer más…

Categorías:Transact-SQL

Varios Tips sobre la importancia de los INDICES – SQL Server

12 diciembre 2011 Deja un comentario

  La creación de índices útiles es uno de lo más importantes para lograr un mejor rendimiento en las consultas. Los índices útiles ayudan a encontrar los datos con menos operaciones de E/S de disco y un menor uso de los recursos del sistema.

Para crear índices útiles, debe comprender cómo se utilizan los datos, los tipos y las frecuencias de ejecución de las consultas y cómo el procesador de consultas puede utilizar los índices para encontrar los datos con rapidez.

Una vez elegidos los índices que creará, examine las consultas más importantes, cuyo rendimiento es el factor que más afecta a la experiencia del usuario. Cree los índices específicamente para ayudar a estas consultas. Luego de agregar un índice, vuelva a ejecutar la consulta para comprobar si el rendimiento ha mejorado. En caso negativo, quite el índice.

Al igual que en la mayoría de las técnicas de optimización del rendimiento, existen ventajas e desventajas. Por ejemplo, con más índices, es probable que las consultas SELECT se ejecuten con mayor rapidez. Pero hay que tener en cuenta que las operaciones DML (INSERT, UPDATE y DELETE) reducirán su velocidad porque se deben mantener más índices con cada operación. Entonces si las consultas son principalmente instrucciones SELECT, el uso de más índices puede ser positivo. Si su aplicación lleva a cabo muchas operaciones DML, el número de índices que cree debería ser más moderado.

En definitiva, puede mejorar el rendimiento de la aplicación SQL Server, optimizando las consultas que utiliza.

Evitar el indizado de tablas pequeñas

Una tabla pequeña es aquella cuyo contenido cabe en una o pocas páginas de datos. Evite crear índices a tablas muy pequeñas porque normalmente es más eficaz realizar una exploración de tablas. De este modo, se evita tener que cargar y procesar las páginas de índices. Si no crea un índice en las tablas muy pequeñas, está eliminando la posibilidad de que el optimizador seleccione una.

Clave primaria y externas

Es recomendable que siempre se cree índices en las claves principales. También suele ser muy útil crear índices en claves externas, puesto que tanto las claves principales como las externas se utilizan con frecuencia para combinar tablas.

Los índices de estas claves permiten al optimizador calcular los algoritmos de combinación de índices más eficaces.

Si la consulta combina tablas utilizando otras columnas, a menudo es útil crear índices en esas columnas por la misma razón. (Tener mucho cuidado al crear este tipo de índices).
 
Cuando se crean las restricciones de claves principales y externas, SQL Server  crea automáticamente índices para ellas y las utiliza para optimizar las consultas. Recuerde que es aconsejable crear claves principales y externas lo más pequeñas posible, ya que las combinaciones son más rápidas.

Índices con cláusulas de filtro

Los índices pueden utilizarse para acelerar la evaluación de ciertos tipos de cláusulas de filtro.

Si bien todas las cláusulas de filtro reducen el conjunto de resultados final de una consulta, algunas de ellas también ayudan a reducir la cantidad de datos que se deben explorar.

Un argumento de búsqueda (SARG) limita una búsqueda porque especifica la coincidencia exacta, un intervalo de valores o una conjunción de dos o más elementos combinados con AND. Presenta uno de los siguientes formatos:
•         Columna operador <constante o variable>
•         <constante o variable> operador Columna

Entre los operadores SARG se incluyen =, >, <, >=, <=, IN, BETWEEN y, en ocasiones, LIKE (en casos de coincidencia de prefijos, tales como LIKE ‘John%’). Un argumento SARG puede incluir varias condiciones combinadas con un AND. Los argumentos SARG pueden ser consultas que coinciden con un valor específico, por ejemplo:

•         “Customer ID” = ‘ANTON’
•         ‘Doe’ = “Last Name”

Un argumento SARG también puede ser una consulta que coincide con un intervalo de valores, por ejemplo:

•         “Order Date” > ’1/1/2002′
•         “Customer ID” > ‘ABCDE’ AND “Customer ID” < ‘EDCBA’
•         “Customer ID” IN (‘ANTON’, ‘AROUT’)

Una expresión que no utilice operadores SARG no mejorará el rendimiento porque el procesador de consultas de SQL Server debe evaluar cada fila para determinar si cumple la cláusula de filtro. Por consiguiente, un índice no es de utilidad en expresiones que no utilizan operadores SARG. Entre los operadores que no son SARG se incluyen NOT, <>, NOT EXISTS, NOT IN, NOT LIKE y funciones intrínsecas.

Crear índices muy selectivos

Los índices en las columnas utilizadas en la cláusula WHERE de las consultas importantes normalmente mejoran el rendimiento. Sin embargo, esto depende del grado de selectividad del índice.

La selectividad es la proporción de filas resultantes respecto al total de filas. Si la proporción es baja, significa que el índice es muy selectivo, ya que puede deshacerse de la mayoría de las filas y reducir en gran medida el tamaño del conjunto de resultados. Por consiguiente, se trata de un índice muy útil. En cambio, un índice que no es selectivo no es tan útil.
Los índices únicos son los más selectivos. Sólo puede coincidir una fila, lo que es realmente útil para las consultas que pretenden exactamente devolver una fila. Por ejemplo, un índice en una sola columna de Id. servirá de ayuda para encontrar con rapidez una fila concreta.

Limpieza del historial de SQL Server (sp_delete_backuphistory)

  

Trabajando con SQL Server como motor de Base de Datos, notaremos que éste crece rápidamente, ocupando mucho espacio en disco, uno de los tantos puntos que hace crecer su tamaño es el historial de sistema, que se almacena dentro de la BD llamada MSDB.

Los datos más importantes que se guardan aquí es la historia de las restauraciones y backups hechos, así que cuanto más usemos éstos recursos, la BD crecerá más.

Es muy importante tener la data de esto por muchos motivos, pero también tenemos que tener en cuenta que es sólo útil por cierto tiempo (la cantidad depende de nuestro objetivo, uso, necesidad).
Por ello es que limpiarlo constantemente, es un deber que tenemos los DBAs.

El motor nos ofrece un procedimiento de sistema que se encarga de hacer optimamente esto por nosotros, sólo debemos decirle de cuanto tiempo atrás queremos purgar.

Las tablas afectadas por el procedimiento son las siguientes:

• backupfile
• backupfilegroup
• backupmediafamily
• backupmediaset
• backupset
• restorefile
• restorefilegroup
• restorehistory

USE msdb;
GO
EXEC sp_delete_backuphistory ’2011/03/02′

 

Eliminar todas las conexiones activas de una base de datos

11 febrero 2011 Deja un comentario

CREATE PROCEDURE dbo.EliminarConexiones
@dbName SYSNAME
AS
BEGIN
SET NOCOUNT ON

DECLARE @spid INT,
@cntactivas INT,
@sql VARCHAR(255)

SELECT @spid = MIN(spid), @cntactivas = COUNT(*)
FROM master..sysprocesses
WHERE dbid = DB_ID(@dbname)
AND spid != @@SPID

PRINT ‘Eliminando ‘+RTRIM(@cntactivas)+‘ procesos.’

WHILE @spid IS NOT NULL
BEGIN
PRINT ‘Eliminando Proceso ‘+RTRIM(@spid)
SET @sql = ‘KILL ‘+RTRIM(@spid)
EXEC(@sql)
SELECT @spid = MIN(spid), @cntactivas = COUNT(*)
FROM master..sysprocesses
WHERE dbid = DB_ID(@dbname) AND spid != @@SPID

PRINT RTRIM(@cntactivas)+‘ Procesos por eliminar.’
END
END
GO


Categorías:Transact-SQL

Para ver la última vez que las bases de datos fueron backupeadas

18 noviembre 2010 Deja un comentario

SELECT B.Name as Database_Name, ISNULL(STR(ABS(DATEDIFF(day, GetDate(),
MAX(Backup_finish_date)))),’NEVER’) AS DaysSinceLastBackup, ISNULL(Convert(CHAR(10), MAX(backup_finish_date), 101), ‘NEVER’) AS LastBackupDate
FROM master.dbo.sysdatabases B LEFT OUTER JOIN msdb.dbo.backupset A
ON A.database_name = B.Name AND A.type = ‘D’
GROUP BY B.Name
ORDER BY B.Name

 

Categorías:Transact-SQL

T-SQL – Gráfica de los distintos tipos de Joins

18 noviembre 2010 Deja un comentario

Creo que esta imagen nos da la respuesta clara y exacta de como funciona cada uno de los JOINS disponibles.

Como encontrar un texto dentro de todos los stored procedures en SQLServer

18 noviembre 2010 2 comentarios

Para realizar nos valemos de la función ROUTINE_DEFINITION que nos devuelve la definición o codificación de cualquier objeto dentro una base de datos.

SELECT ROUTINE_NAME, ROUTINE_DEFINITION
FROM INFORMATION_SCHEMA.ROUTINES
WHERE ROUTINE_DEFINITION LIKE ‘%loquebusco%’ AND ROUTINE_TYPE = ‘PROCEDURE’

Convertir segundos a un TimeString (hh:mm:ss)

5 octubre 2010 Deja un comentario

   Esta función convierte un número de segundos a un formato “humano” del tiempo. por ejemplo, (302 segundos se representa como ’00: 05:02 ‘, es decir, 5 minutos y 2 segundos)

CREATE FUNCTION [dbo].[udf_SegusndosDateDiff ](@Duracion INT) RETURNS VARCHAR(8)
AS
    BEGIN
        RETURN (SELECT CONVERT(VARCHAR(8),DATEADD(SECOND,@Duracion,0),114))
 END
GO

Encontrar la diferencia de datos entre dos conjuntos de datos …

5 octubre 2010 Deja un comentario

  Encontrar la diferencias de los registros entre 2 tablas de la misma estructura

DECLARE @vSQL VARCHAR(MAX)
DECLARE @vCols VARCHAR(MAX)

– Crear tablas de prueba
CREATE TABLE vTable1 (ID INT, IDEstudiante INT, Departamento VARCHAR(10),IDLibro INT)
CREATE TABLE vTable2 (ID INT, IDEstudiante INT, Departamento VARCHAR(10),IDLibro INT)
– Ingresamos datos de prueba
INSERT INTO vTable1
SELECT 1,123,‘CS’,465 UNION ALL
SELECT 2,123,‘CS’,345 UNION ALL
SELECT 3,223,‘TE’,190
INSERT INTO vTable2
SELECT 1,123,‘CS’,465 UNION ALL
SELECT 2,223,‘TE’,345 UNION ALL
SELECT 3,223,‘TE’,190

– Obtener los nombres de las columnas del esquema con las declaraciones
– para obtener 0 o 1 como resultado, esto dependerá de las columnas de las tablas reales

SELECT @vCols = Stuff((Select ‘,case when a.’ + [name] + ‘ = b.’ + [name] + ‘ then Cast(b.’ + [name] +
‘ as varchar(10)) else cast(b.’ + [name] + ‘ as varchar(max)) + ”(anterior)” + ” ” + Cast(a.’ + [name] +
‘ as varchar(10)) + ”(nuevo)” end as ‘ + [name]
FROM sys.columns
WHERE Object_id = Object_id(‘vTable1′) FOR XML PATH(”)),1,1,”)

– Utilizar @vCols con el select para obtener las diferencias
SET @vSQL = ‘ Select a.id,’ + @vCols + ‘ From vTable1 a Inner Join vTable2 b on b.ID = a.ID ‘

PRINT @vSQL
EXEC (@vSQL)

– Flag de las columnas para ver las diferencias
SELECT @vCols = Stuff((SELECT ‘,Case when a.’ + [name] + ‘ = b.’ + [name] + ‘ Then 1 Else 0 End as ‘ + [name]
FROM sys.columns
WHERE Object_id = Object_id(‘vTable1′) FOR XML PATH()),1,1,)

– Utilizar @vCols con el select para obtener las diferencias
– 1 : si los datos son los mismos     0 : si los datos son diferentes
SET @vSQL = ‘ Select a.id,’ + @vCols + ‘ From vTable1 a Inner Join vTable2 b on b.ID = a.ID ‘

PRINT @vSQL
EXEC (@vSQL)

DROP TABLE vTable1
DROP TABLE vTable2

Ver imagen :

Copiar estructura de tabla sin datos mediante una línea de consulta

9 septiembre 2010 Deja un comentario

  Copiar estructura de tabla sin datos mediante una línea de consulta.

SELECT * FROM TuTabla
SELECT * Into TuTablaTmp FROM TuTabla WHERE 1=2
SELECT * FROM TuTablaTmp 

Seguir

Recibe cada nueva publicación en tu buzón de correo electrónico.