TRABAJO DE INVESTIGACION

DML EN SQL SERVER

JOHN VICENTE PINEDA

PROGRAMA DE INGENIERIA INFORMATICA

FACULTAD DE INGENIERIAS EN INFORMATICA

CORPORACION UNIVERSITARIA AUTONOMA DE NARIÑO

SANTIAGO DE CALI, Mayo de 2018.
 TRABAJO DE INVESTIGACION

DML EN SQL SERVER

JOHN VICENTE PINEDA

Trabajo de investigación para la materia Electiva II

Director: Aldemar Cuartas

Ingeniera Informática

Aldemar.cuartas@aunarcali.edu.co

PROGRAMA DE INGENIERIA INFORMATICA

FACULTAD DE INGENIERIAS EN INFORMATICA
CORPORACION UNIVERSITARIA AUTONOMA DE NARIÑO
SANTIAGO DE CALI, Mayo de 2018.
 TABLA DE CONTENIDO

1. INTRODUCCION ......................................................................................... 3
2. INSTRUCCIONES BASICAS DML EN SQL SERVER. .............................. 4
2.1 OPERADORES LOGICOS. ................................................................... 5
2.2 SENTENCIA INSERT ............................................................................ 6
2.3 SENTENCIA UPDATE .......................................................................... 6
2.4 SENTENCIA DELETE ........................................................................... 7
3. INTRUCCIONES BASICAS DDL EN SQL SERVER. ................................. 8
3.1 SENTENCIA CREATE ......................................................................... 8
4. ADO.NET Y SU APLICACIÓN PRACTICA. ............................................. 10
5. COMANDOS DE BASE DE DATOS DENTRO DE C#. .......................... 21
5.1 SQL CONECTION ............................................................................... 21
REFERENCIAS. ............................................................................................... 26
CONCLUSIONES ............................................................................................. 25
1. INTRODUCCION

Este trabajo estudia los conceptos relacionados con las instrucciones básicas
usadas en DML SQL server, fundamentales para la administración de
sistemas, utilizados en pequeñas y medianas empresas, dentro de los
conceptos podemos destacar aspectos generales sobre su aplicación,
sintaxis y modos de uso en las bases de datos.
Estos conceptos ayudaran a reforzar el conocimiento del lenguaje de C# y
fundamentará nuestros conocimiento y experiencia en punto net, generando una
capacidad para la solución de problemas relacionados con la administración
de bases de datos, debido a la amplia variedad de temas expuestos en el
trabajo, podremos familiarizarnos con conocimientos básicos y terminología
usada en el manejo de bases de datos.
Se analizaran, temas fundamentales como las sentencias usadas en sql y
profundizaremos en la aplicación práctica que tiene cada una de las
sentencias.

3
2. INSTRUCCIONES BASICAS DML EN SQL SERVER.
El lenguaje SQL está compuesto por comandos, cláusulas, operadores y
funciones de agregado. Estos elementos se combinan en las instrucciones para
crear, actualizar y manipular las bases de datos.
Lenguaje de definición de datos (DDL – Data Definition Language)
Un esquema de bases de datos se representa mediante un sublenguaje especial
llamado lenguaje de definición de datos. El resultado de la compilación de estas
instrucciones es un conjunto de tablas, relaciones y reglas cuyas definiciones
quedan almacenadas en un archivo (tabla u otro medio de almacenamiento) que
contiene “metadatos”, esto es, datos acerca de datos. Este archivo comúnmente
llamado diccionario de datos (o catalogo del sistema) es el que se consulta toda
vez que se quiere leer, modificar o eliminar los datos de la base de datos.

Lenguaje de manipulación de datos (DML – Data Manipulation Language)

Un D.M.L. es un sublenguaje de consulta y manipulación de datos.
Se entenderá por manipulación de datos la:
Recuperación de Información.
Inserción de nueva Información.
Eliminación (Borrado) de información existente.
Modificación de Información Almacenada.

Los DCL (Data Control Language) que se encargan de definir las permisos
sobre los datos

DML.
Lenguaje de Manipulación de Datos.

SELECT Utilizado para consultar registros de la base de datos que

satisfagan un criterio determinado
INSERT Utilizado para cargar lotes de datos en la base de datos en una
única operación.
UPDATE Utilizado para modificar los valores de los campos y registros
especificados
DELETE Utilizado para eliminar registros de una tabla de una base de datos
Clausulas.

Las cláusulas son condiciones de modificación utilizadas para definir los datos
que desea seleccionar o manipular.
4
FROM Utilizada para especificar la tabla de la cual se van a seleccionar
los registros
WHERE Utilizada para especificar las condiciones que deben reunir los
registros que se van a seleccionar
GROUP BY Utilizada para separar los registros seleccionados en grupos
específicos
HAVING Utilizada para expresar la condición que debe satisfacer cada grupo
ORDER BY Utilizada para ordenar los registros seleccionados de acuerdo con
un orden específico

2.1 OPERADORES LOGICOS.

Operador Uso
AND Es el “y” lógico. Evalua dos condiciones y devuelve un valor de verdad
sólo si ambas son ciertas.
OR Es el “o” lógico. Evalúa dos condiciones y devuelve un valor de verdar
si alguna de las dos es cierta.
NOT Negación lógica. Devuelve el valor contrario de la expresión.
Operadores Relacionales.

Operador Uso
< Menor que
> Mayor que
<> Distinto de
<= Menor ó Igual que
>= Mayor ó Igual que
= Igual que
BETWEEN Utilizado para especificar un intervalo de valores.
LIKE Utilizado en la comparación de un modelo
In Utilizado para especificar registros de una base de datos

Ejemplo de Insert.
Insert into alumnos values(120,”Oscar”,”Lopez”,”Gomez”);

5
Ejemplo de Delete.
Delete from alumnos where edad>=40;

Ejemplo de Update.
Update productos set precio=precio*1.15 where categoria=farmacia;
Ejemplo de Select

Lista los nombres, oficinas y fechas de contrato de todos los vendedores.

Select nombre, oficina_rep, fecha_contrato from repventas;

Cual es el nombre, cuota y ventas del empleado numero 107

Select nombre, cuota, venta From repventas Where Num_emple=107;

2.2 SENTENCIA INSERT

La sentencia INSERT INTO se utiliza para insertar nuevas filas en una tabla.

Es posible insertar una nueva fila en una tabla de dos formas distintas:

INSERT INTO nombre_tabla

VALUES (valor1, valor2, valor3…)

INSERT INTO nombre_tabla (columna1, columna2, columna3…)

VALUES (valor1, valor2, valor3 …)

2.3 SENTENCIA UPDATE

La sentencia UPDATE se utiliza para modificar valores en una tabla.
La sintaxis de SQL UPDATE es:

UPDATE nombre_tabla
SET columna1 = valor1, columna2 = valor2
WHERE Columna3 = valor 3

La cláusula SET establece los nuevos valores para las columnas indicadas.
La cláusula WHERE sirve para seleccionar las filas que queremos modificar.
6
Si omitimos la cláusula WHERE, por defecto, modificará los valores en todas las
filas de la tabla.

2.4 SENTENCIA DELETE

La sentencia DELETE sirve para borrar filas de una tabla.
La sintaxis de SQL DELETE es:
DELETE FROM nombre_tabla
WHERE nombre_columna = valor
Si queremos borrar todos los registros o filas de una tabla, se utiliza la sentencia:
DELETE * FROM nombre_tabla;

2.5 SENTENCIA SELECT

Una de las sentencias SQL más importantes es SELECT, ya que permite realizar
consultas sobre los datos almacenados en la base de datos.
Sintaxis SQL SELECT
SELECT * FROM nombre_tabla
SELECT columna1, columna2 FROM nombre_tabla

7
3. INTRUCCIONES BASICAS DDL EN SQL SERVER.
lenguaje de definición de datos (Data Definition Language, DDL por sus siglas
en inglés) es un lenguaje proporcionado por el sistema de gestión de base de
datos que permite a los programadores de la misma llevar a cabo las tareas de
definición de las estructuras que almacenarán los datos así como de los
procedimientos o funciones que permitan consultarlos.

Un Data Definition Language o Lenguaje de descripción de datos ( DDL ) es un

lenguaje de programación para definir estructuras de datos . El término DDL fue
introducido por primera vez en relación con el modelo de base de datos
CODASYL, donde el esquema de la base de datos ha sido escrito en un lenguaje
de descripción de datos que describe los registros, los campos, y "conjuntos" que
conforman el usuario modelo de datos. Más tarde fue usado para referirse a un
subconjunto de SQL, pero ahora se utiliza en un sentido genérico para referirse
a cualquier lenguaje formal para describir datos o estructuras de información,
como los esquemas XML .

3.1 SENTENCIA CREATE

La sentencia CREATE TABLE se utiliza para crear una tabla en una base de
datos existente.
Sintaxis CREATE TABLE
CREATE TABLE nombre_tabla
{
Nombrecolumna1 tipodato1,
Nombrecolumna2 tipodato2,
Nombrecolumna3 tipodato3,…
}

3.2 SENTENCIA ALTER.

La sentencia SQL ALTER se utiliza para añadir, eliminar o modificar columnas
de una tabla.
Sintaxis SQL ALTER
Para añadir una nueva columna a una tabla
ALTER TABLE nombretabla
DROP COLUMN nombrecolumna

Para modificar el tipo de dato de una columna de una tabla.

ALTER TABLE nombretabla

8
ALTER COLUMN nombrecolumna tipodatocolumna.

3.3 SENTENCIA DROP.

La sentencia DROP se utiliza para borrar definitivamente un índice, tabla o base

de datos.

DROP INDEX

Sintaxis DROP INDEX para MySQL.

ALTER TABLE nombretabla

DROP INDEX nombreindice.

Sintaxis DROP INDEX para Access

DROP INDEX nombreindice

ON nombretabla

Sintaxis DROP INDEX para SQL SERVER.

DROP INDEX nombretabla.nombreindice

Sintaxis DROP TABLE

Se utiliza DROP TABLE para borrar definitivamente una tabla

DROP TABLE nombretabla.

DROP DATABASE
Se utiliza para borrar una base de datos definitivamente.
DROP DATABASE nombrebasededatos.

9
4. ADO.NET Y SU APLICACIÓN PRACTICA.

ADO.NET es un conjunto de clases que exponen servicios de acceso a datos

para programadores de .NET Framework.Constituye una parte integral de .NET
Framework y proporciona acceso a datos relacionales, XML y de aplicaciones.
Las clases que nos brinda ADO.NET representan todos los conceptos básicos y
necesarios para acceder a cualquier orígen de datos y realizar cualquier tipo de
operación: Conexión, Transacción, Comando, Parametro, Set de datos, Tabla, y
más.Es importante que conozcamos qué es y cómo funciona ADO.NET porque
siempre lo vamos a estar utilizando al acceder a datos, ya sea de manera directa
mediante el uso de sus clases o de manera indirecta al utilizar alguna
herramienta de mapeo de objetos a datos (ORM) o librería de terceros, las cuales
internamente harán uso de ADO.NET.Es muy importante leer la documentación
existente en el Sitio oficial y siempre es muy útil seguir las novedades en el Blog
oficial.
La cantidad de artículos y videos no oficiales que existen con tutoriales del estilo
“Cómo conectarse a SQL Server desde C#” o “Accediendo a datos con .NET”,
es incontable y crece día a día. Pero, lamentablemente, es común encontrar en
ellos errores y/o malas prácticas que afectan la seguridad y/o performance de la
aplicación final. Debemos destacar las mejores prácticas que podemos seguir y
también mencionar los principales errores que debemos evitar, basado en
experiencias y en libros/documentación oficial.
4.1 CADENAS DE CONEXIÓN.

Para poder conectarnos a un orígen de datos, vamos a necesitar una cadena de

conexión o Connection String. Es altamente probable que una cadena de
conexión cambie, por ej.: porque cambia el ambiente en el cual se está
ejecutando la aplicación (desarrollo, testing, producción, etc.) o porque
cambiaron las credenciales de acceso a una BD.
Es por esto que debemos evitar definir las cadenas de conexión dentro del
código (hard-coded), ya que para cambiarlas vamos a tener que: modificar el
código, compilar e instalar la nueva versión de la aplicación. Lo recomendable
entonces, es definirlas en algún medio en el cual puedan ser modificadas de
manera fácil, rápida y sin afectar la aplicación.
Siguiendo esta recomendación, el medio recomendado para las cadenas de
conexión es el archivo de configuración de la aplicación (web.config o app.config,
según el tipo de aplicación). Allí contamos con la sección dedicada al respecto
<connectionStrings>.

10
MODO INEFICAZ:
string connectionString = "Server=.;Database=Ejemplo;Integrated
Security=True";
using (var conn = new SqlConnection(connectionString))
{
// ...
}

MODO EFICIENTE.
<connectionStrings>
<add name="EjemploBD"
connectionString="Server=.;Database=Ejemplo;Integrated Security=True"
providerName="System.Data.SqlClient" />
</connectionStrings>

string connectionString =
ConfigurationManager.ConnectionStrings["EjemploBD"].ConnectionString;
using (var conn = new SqlConnection(connectionString))
{
// ...
}

Opcionalmente, también contamos con la funcionalidad de encriptar todas las

cadenas de conexión del archivo de configuración para una mayor seguridad.
NO usar “conexiones estáticas”
Existen proyectos que usan una variable estática para guardar el objeto de
conexión a la BD. Probablemente la intención de esto es evitar abrir nuevas
conexiones para cada operación que se desea realizar, ya que es un proceso
costoso (tanto en tiempo como recursos).

11
Guardar la conexión en una variable estática implica que ésta será única para
toda la aplicación. Lo cual sería completamente aceptable si la aplicación
utilizara un único hilo de ejecución y fuera usado por un único usuario, sin ningún
tipo de concurrencia. Aunque difícilmente una aplicación tendrá dichas
características…
Pongamos como ejemplo una aplicación web que usa una “conexión estática”:
cada usuario que acceda al sitio será atendido usando un nuevo hilo de ejecución
del proceso que ejecuta la aplicación, imaginemos que un primer usuario
accederá a una página que utilizará la conexión para obtener una lista de
registros a mostrar, y ahora imaginemos que un segundo usuario accede en ese
preciso instante a otra página de la aplicación la cual también intentará utilizar la
conexión para obtener otra lista de registros a mostrar, pero lamentablemente se
encontrará con que la conexión no está disponible y verá un “hermoso” mensaje
de error en pantalla… Sólo por mencionar uno de los tantos escenarios de error
posibles.
En definitiva: “conexión estática” = muy mala práctica.
Entonces, ¿cómo abrir una conexión sin problemas y de la manera mas
performante? La respuesta es simple:
Crear una conexión.
Abrir la conexión.
Usar la conexión para realizar las operaciones necesarias.
Cerrar la conexión.
4.2 LIBERAR RECURSOS.

Pero, ¿no es acaso costoso abrir una nueva conexión? Si. Pero ADO.NET
emplea un proceso llamado Connection Pooling o agrupación de conexiones
para resolver este problema. Para explicarlo de manera resumida y muy
simplificada, se encarga de llevar una lista de las últimas conexiones abiertas y
cada vez que se intente abrir una nueva conexión busca en dicha lista alguna
similar para reutilizarla. Todo esto sucede mágicamente bajo nuestras narices, y
por lo tanto podemos despreocuparnos del tema.
Liberar los recursos luego de utilizarlos
Este aspecto no es algo propio del ADO.NET, sino más bien de todo el
Framework .NET y que siempre debemos tenerlo en cuenta en el desarrollo de
nuestras aplicaciones.
Haciendo un resúmen podemos decir lo siguiente:
Existen objetos que internamente utilizan ciertos recursos que deben ser
liberados luego de ser utilizados (entre ellos, las conexiones a bases de datos).
Estos objetos implementan la interfaz IDisposable, que publica un único método
12
Dispose, el cual se encarga de liberar dichos recursos. Quien utiliza estos objetos
tiene la responsabilidad de llamar siempre al método Dispose una vez que haya
finalizado con su utilización. No liberar estos recursos puede deteriorar la
performance de la aplicación, y en algunos casos extremos incluso puede causar
la caída del servidor (al agotar el procesamiento/memoria). La manera más
conveniente de asegurar la llamada al método Dispose de un objeto es mediante
el uso del bloque using. Este bloque permite declarar cualquier objeto que
implemente la interfaz Dispose, dentro del cual estará disponible para ser
utilizado dicho objeto, y se encargará de llamar automáticamente al método
Dispose cuando se finalice la ejecución de todas las instrucciones que contiene,
incluso si se produce un error
Con ADO.NET, debemos asegurarnos de liberar todos los recursos de los
objetos luego de utilizarlos. Podemos determinar fácilmente cuales son estos
objetos verificando si implementan la interfaz IDisposable.

MODO INEFICAZ:

var conn = new

SqlConnection(ConfigurationManager.ConnectionStrings["EjemploBD"].Connec
tionString);
conn.Open();

var command = new SqlCommand("SELECT * FROM Usuarios", conn);

var reader = command.ExecuteReader();
while (reader.Read())
{
// ...
}
// Si se produce un error antes de llegar a esta línea, "reader" no se cierra ni
libera correctamente sus recursos
reader.Close();
reader.Dispose();
// Si se produce un error antes de llegar a esta línea, "command" no libera
correctamente sus recursos
command.Dispose();
13
 // Si se produce un error antes de llegar a esta línea, "conn" no se cierra ni libera
correctamente sus recursos
conn.Close();
conn.Dispose();

MODO EFICIENTE:
// Este bloque using cierra y libera automáticamente los recursos utilizados por
"conn"
using (var conn = new
SqlConnection(ConfigurationManager.ConnectionStrings["EjemploBD"].Connec
tionString))
{
conn.Open();
// Este bloque using libera automáticamente los recursos utilizados por
"command"
using (var command = new SqlCommand("SELECT * FROM Usuarios", conn))

// Este bloque using cierra y libera automáticamente los recursos utilizados

por "reader"
using (var reader = command.ExecuteReader())
{
while (reader.Read())
{
// ...
}
}
}

4.3 USO DE PARAMETROS.

En la mayoría de los casos, definimos la consulta o comando a ejecutar de

manera dinámica, en base a datos ingresados/seleccionados por el usuario o
14
según las reglas de negocio definidas. En estos casos, hay quienes directamente
definen en una cadena de texto la consulta, concatenando directamente los
datos ingresados por el usuario formateando (cuando corresponda) textos,
números, fechas, etc.

Por ejemplo:
string cmdTexto = String.Format("SELECT * FROM Usuarios WHERE Login =
'{0}'", login);
using (var command = new SqlCommand(cmdTexto, conn))
{
// ...
}
Esta metodología tiene muchas falencias, pero las dos mas importantes a
destacar son:
Presenta un grave riesgo de seguridad, frente a la técnica SQL Injection.
Necesita una “conversión manual” de tipos de datos al armar la consulta SQL.
Lo cual es “trabajoso” y muy propenso a error.
La manera mas eficiente y segura de especificar los parámetros a utilizar en una
consulta es mediante el uso del objeto ADO.NET que representa un parámetro.
Podemos crearlo indicando solamente su nombre y su valor, para finalmente
agregarlo a la lista de parámetros del comando. De esta manera, tanto la
consulta SQL como la lista de parámetros serán enviados al orígen de datos sin
que nosotros tengamos que hacer ninguna verificación de seguridad ni
conversión de datos alguna.

MODO INEFICAS E INSEGURO :

var cmdTexto = String.Format(

"INSERT INTO Usuarios (Login, EstaActivo, FechaCreacion) VALUES ('{0}',
{1}, '{2})",
login, estaActivo ? 1 : 0, fechaCreacion.ToString("yyyy-MM-dd HH:mm:ss"));

using (var command = new SqlCommand(cmdTexto, conn))

{
15
 int filasAfectadas = command.ExecuteNonQuery();
}

MODO EFICIENTE:

var cmdTexto = "INSERT INTO Usuarios (Login, EstaActivo, FechaCreacion)

VALUES (@Login, @EstaActivo, @FechaCreacion)";
using (var command = new SqlCommand(cmdTexto, conn))
{
command.Parameters.Add(new SqlParameter("@Login", login));
command.Parameters.Add(new SqlParameter("@EstaActivo", estaActivo));
command.Parameters.Add(new SqlParameter("@FechaCreacion",
fechaCreacion));

int filasAfectadas = command.ExecuteNonQuery();

}

4.4 MANEJO DE TRANSACCIONES.

Las clases ADO.NET tienen las clases y métodos necesarios para gestionar
transacciones. Uno debe utilizar el método BeginTransaction en el objeto de la
conexión, el cual inicia una transacción y devuelve un nuevo objeto que la
representa. Este objeto debe ser asignado en los comandos que se desean
ejecutar dentro del contexto de dicha transacción, y finalmente, debe ser aplicada
(commit) o deshechada (rollback).

Sin embargo, existe una manera más sencilla e incluso más potente de manejar
transacciones, mediante el uso de una clase del Framework llamada
System.Transactions.TransactionScope. Para poder utilizar esta clase será
necesario agregar una referencia a la librería System.Transactions del
Framework.

En su uso más básico, simplemente basta definir un bloque en el cual se crea

una instancia de la clase TransactionScope, y automáticamente todas las
16
operaciones siguientes se ejecutarán dentro del contexto de una transacción.
Todo esto se gestionará de manera automática y transparente para nosotros. Lo
único que debemos hacer es llamar al método Complete antes de finalizar el
bloque para aplicar todas las operaciones realizadas, de lo contrario se desharán
todos los cambios.

También cuenta con la capacidad de decidir si es necesario crear una

transacción distribuída, en caso de haber realizado operaciones que afecten a
más de un orígen de datos, y lo hace también de manera automática. Esto se
hace sólo si es estrictamente necesario, eficientizando al máximo el
procesamiento.
Un ejemplo:
using (var scope = new TransactionScope())
{
using (var conn1 = new System.Data.SqlClient.SqlConnection(connString))
{
conn1.Open();

using (var cmd1 = conn1.CreateCommand())

{
cmd1.CommandText = commandText1;
cmd1.ExecuteNonQuery();
}
}

using (var conn2 = new System.Data.SqlClient.SqlConnection(connString))

{
conn2.Open();

using (var cmd2 = conn2.CreateCommand())

{
cmd2.CommandText = commandText2;
17
 cmd2.ExecuteNonQuery();
}
}
scope.Complete();
}
Uso de herramientas de mapeo de objetos a datos (ORM’s)
En mi opinión personal, una de las mejores alternativas es utilizar algún ORM
que se encargue de resolver el acceso a datos, permitiéndonos enfocar pura y
exclusivamente en la función principal de nuestra aplicación, brindando así valor
agregado constantemente.

Estas herramientas también suelen ser la mejor opción ya que, al ser

precisamente su principal función resolver el acceso a datos, lograrán una gran
madurez y performance que probablemente nos tomaría a nosotros mucho
tiempo.

EntityFramework es el ORM que recomiendo usar en las aplicaciones .NET.

Anexo: Acceso a datos único para cualquier tipo de BD.

Generalmente, al crear nuestras aplicaciones ya decidimos cual será el tipo de
BD que usaremos: SQL Server, MySQL, Oracle, etc. Y podemos crear nuestra
lógica de acceso a datos utilizando las clases ADO.NET correspondientes.
Sin embargo, existen aplicaciones que usan más de un tipo de BD. O quizás
exista una alta probabilidad de migrar a otro tipo en alguna etapa avanzada del
desarrollo.Gracias a los patrones de diseño aplicados al diseñar las clases de
ADO.NET, es muy fácil crear lógica de acceso a datos reutilizable para cualquier
tipo de BD. Para ello es necesario hacer uso de las clases bases, de las cuales
todos los Providers o proveedores de ADO.NET deben heredar.

Un ejemplo :
var dbFactory = DbProviderFactories.GetFactory(providerName);
if (dbFactory == null)
throw new ArgumentException("providerName");

18
using (var conn = dbFactory.CreateConnection())
{
conn.ConnectionString = connectionString;
conn.Open();

using (var cmd = conn.CreateCommand())

{
cmd.CommandText = cmdText;

// Se pueden agregar parámetros

var p1 = cmd.CreateParameter();
p1.ParameterName = "@Parametro1";
p1.Value = new DateTime(2014, 2, 24);
cmd.Parameters.Add(p1);

// Ejecutar comando con la operación necesaria

int filasAfectadas = cmd.ExecuteNonQuery();

object valor = cmd.ExecuteScalar();

// Abrir un DataReader para recorrer la lista de registros obtenidos por el

comando
using (var reader = cmd.ExecuteReader())
{
while (reader.Read())
{
// hacer lo necesario con cada registro
}
reader.Close();
19
 }
}
}
En el código pueden ver las variables:

providerName. Nombre del proveedor ADO.NET a utilizar. Ejemplos:

"System.Data.SqlClient"
"System.Data.Odbc"
connectionString. Cadena de conexión a utilizar. Ejemplos:
"Server=(localhost);Database=Sistema;Integrated Security=True"
"Server=(localhost);Database=Sistema;User ID=sa;Password=*****"
cmdText. Texto de la sentencia SQL a ejecutar. Ejemplos:
"SELECT [UsuarioId], [NombreUsuario], [EstaActivo] FROM [Usuarios]"
"UPDATE [Usuarios] SET [EstaActivo] = @EstaActivo WHERE [UsuarioId] =
@UsuarioId"

20
5. COMANDOS DE BASE DE DATOS DENTRO DE C#.

5.1 SQL CONECTION

Representa una coneccion abierta a una base de datos de SQL server, esta
clase no puede heredarse.

Espacio de nombres: System.Data.SqlClient

Ensamblado: System.Data (en System.Data.dll)

Jerarquía de herencia
System.Object
System.MarshalByRefObject
System.ComponentModel.Component
System.Data.Common.DbConnection
System.Data.SqlClient.SqlConnection

SINTAXIS.

Public sealed class SqlConnection : DbConecction, ICloneable

CONSTRUCTORES.

SqlConnection Inicializa una nueva instancia de la clase SqlConection.

SqlConection(String) Inicializa una nueva intancia de la calse SqlConection,
Dada una cadena que contiene la cadena de conexión.
SqlConnection(String, SqlCredential) Iniclaiza una nueva instancia de la
calse SqlConection a la que se proporciona una cadena conexión que no
usa Integrated Segurity = true y un objeto SQlCredential que contiene el
identificador de usuario y la contraseña.

5.2 SQL COMMAND.

Representa un porcedimiento almacenado o una instrucción de

Transact_SQL que se ejecuta en una base de datos de SQL Server. Esta
clase no puede heredarse.
21
Espacio de nombres: System.Data.SqlClient
Ensamblado: System.Data (en System.Data.dll)

Jerarquía de herencia
System.Object
System.MarshalByRefObject
System.ComponentModel.Component
System.Data.Common.DbCommand
System.Data.SqlClient.SqlCommand
SINTAXIS.
Public sealed classs SqlCommnad : DBCommand, ICcloneable

CONSTRUCTORES.
SqlComand Inicializa una nueva instancia de la clase SqlCommand.
SqlCommnad(String) Inicializa una nueva instancia de la clase SqlCommand
con el text de la consulta.
SqlCommand(String,SqlConnection) Inicializa una nueva instancia de la
calse SqlCommand con el texto de la consulta y una conexión SqlConnection.
SqlCommand(String, SqlConnection,SqlTransaction) Inicializa una nueva
instancia de la clase SqlCommand con el texto de la consulta, un objeto
SqlConnection y el objeto SqlTransaction.
SqlCommand(String,SqlConnection,SqlTransaction,SqlCommandColumn
EncryptionSetting) Inicializa una nueva instancia de la clase SqlComand con
texto de commandos especificado, conexion, transaccion y configuracion de
cifrado.

5.3 SQL PARAMETER.

Representa un parámetro para un elemento SqlCommnad y, de forma opciona,
su asignación a columnas DataSet. Esta clase no puede heredarse.
Espacio de nombres: System.Data.SqlClient
Ensamblado: System.Data (en System.Data.dll)

Jerarquía de herencia
System.Object
System.MarshalByRefObject
System.Data.Common.DbParameter

22
 System.Data.SqlClient.SqlParameter
SINTAXIS.
Public sealed class SqlParameter : DbParameter, IDbDataParameter,
IDataParameter, ICloneable.

CONSTRUCTORES

SqlParameter() Inicializa una nueva instancia de la clase SqlParameter.

SqlParameter(String, Object) Inicializa una nueva instancia de la clase
SqlParameter que usa el nombre de parámetro y un valor del nuevo elemento
SqlParameter.
SqlParameter(String, SqlDbType) Inicializa una nueva instancia de la clase
SqlParameter que usa el nombre de parámetro y el tipo de datos.
SqlParameter(String, SqlDbType, Int32) Inicializa una nueva instancia de la
clase SqlParameter que usa el nombre del parámetro, el SqlDbType y el tamaño.
SqlParameter(String, SqlDbType, Int32, ParameterDirection, Boolean,
Byte, Byte, String, DataRowVersion, Object) Inicializa una nueva
instancia de la clase SqlParameter que usa el nombre, el tipo y el tamaño del
parámetro, una ParameterDirection, l precisión y la escala del parámetro, la
columna de origen, una DataRowVersion que se usará y el valor del parámetro.
SqlParameter(String, SqlDbType, Int32, ParameterDirection, Byte, Byte,
String, DataRowVersion, Boolean, Object, String, String, String)
Inicializa una nueva instancia de la clase SqlParameter que usa el nombre del
parámetro, el tipo del parámetro, la longitud del parámetro, la dirección, la
precisión, la escala, el nombre de la columna de origen, uno de los valores de
DataRowVersion, un valor booleano para la asignación de la columna de origen,
el valor de SqlParameter, el nombre de la base de datos donde se encuentra la
colección de esquemas para esta instancia XML, el esquema relacional
propietario donde se encuentra la colección de esquemas para esta instancia
XML y el nombre de la colección de esquemas para este parámetro.

SqlParameter(String, SqlDbType, Int32, String) Inicializa una nueva

instancia de la clase SqlParameter que usa el nombre del parámetro, el
SqlDbType, el tamaño y el nombre de la columna de origen.

23
5.4 SQL DATA ADAPTER.

Representa un conjunto de comandos de datos y una conexión a una base de

datos que se usan para rellenar DataSet y actualizar una base de datos de SQL
Server. Esta clase no puede heredarse.

Espacio de nombres: System.Data.SqlClient

Ensamblado: System.Data (en System.Data.dll)

Jerarquía de herencia
System.Object
System.MarshalByRefObject
System.ComponentModel.Component
System.Data.Common.DataAdapter
System.Data.Common.DbDataAdapter
System.Data.SqlClient.SqlDataAdapter

SINTAXIS

Public sealed class SqlDataAdapter : DbDataAdapter, IDbDataAdapter,

IDataAdapter, ICloneable

SqlDataAdapter() Inicializa una nueva instancia de la clase SqlDataAdapter.

SqlDataAdapter(SqlCommand) Inicializa una nueva instancia de la
SqlDataAdapter clase con el parámetro SqlCommand como el SelectCommand
propiedad.
SqlDataAdapter(String, SqlConnection) Inicializa una nueva instancia de la
SqlDataAdapter clase con un SelectCommand y un SqlConnection objeto.
SqlDataAdapter(String, String) Inicializa una nueva instancia de la
SqlDataAdapter clase con un SelectCommand y una cadena de conexión.

24
CONCLUSIONES

SQL permite ingresar comandos, con los cuales podemos administrar y crear
bases de datos, su modificación o mantenimiento basado entablas nos permite
tener acceso para poder recuperar datos importantes de manera muy
práctica.
La seguridad que nos ofrece SQL, garantiza la integridad lógica de los datos,
la migración o exportación de datos, puede variar desde archivos tipo texto,
hojas sin formatos etc. de cálculo, archivos de texto.
La cantidad de información que se tendría sin base de datos es inimaginable,
con bases de datos como SQL, se obtiene versatilidad en el manejo y
manipulación de los mismos.
Por los anterior, SQL es una poderosa herramienta que nos permitirá realizar
diversas tareas relacionadas con el manejo de datos, herramienta practica y
de fácil manejo para el desarrollo de sistemas informático.

25
 REFERENCIAS.

[1] MIcrosoft, «msdn.microsoft.com,» 2018. [En línea]. Available:

https://msdn.microsoft.com/es-
es/library/system.data.sqlclient.sqldataadapter(v=vs.110).aspx. [Último
acceso: 05 05 2018].
[2] M. Lopez, «matiaslopezdev.wordpress.com,» 22 12 2014. [En línea].
Available: https://matiaslopezdev.wordpress.com/2014/12/04/ado-net-
buenas-practicas-en-el-acceso-a-datos. [Último acceso: 05 05 2018].

26
27