lunes, 22 de octubre de 2012

Google Maps en WinForms

En esta sección muestro un pequeño ejemplo de ejecutar Google Maps en un formulario de visual studio .net (Winform) utilizando código Visual Basic y la librería Pegazux.Controls.dll. 




Adjunto lo siguiente:

Pegazux.Controls.dll
Código Fuente
Proyecto en Visual  Studio

Descargar Todo Aquí

Nota: Si desea ejecutar el proyecto, su ordenar debe tener conexión a internet.

viernes, 19 de octubre de 2012

Sql Server - Validar Existencia de Tabla Temporal

Este script permite validar si la tabla temporar existe en el entorno de SQL, además de validar si el usuario establecido se encuentra o no registrado en la tabla.


if OBJECT_ID('tempdb..#temp') is not null
BEGIN
        IF(EXISTS (SELECT * FROM #temp where idUsuario = 1))
          BEGIN
               PRINT 'EL USUARIO YA EXISTE'
          END
           ELSE
               BEGIN
                 INSERT INTO dbo.#temp values (1,1) 
                    PRINT 'SE HA INGRESADO EL PRIMER USUARIO'
               END   
  END
  ELSE
     BEGIN
          CREATE TABLE dbo.#temp
    (idUsuario int PRIMARY KEY,
       sesion_iniciada bit
    );
          INSERT INTO dbo.#temp values (1,1) 
          PRINT 'TABLA CREADA'
     END
Resultado
TABLA CREADA

Query OK, 1 rows affected (219 ms)

SQL Server - Función para Encriptar y Desencriptar Contraseñas

Estas funciones que le mostraré a continuación permiten registrar un contraseña o dato en una tabla Sql de manera encriptada, y otra que facilite al usuario desencriptarla. Para encriptar un dato y registrarlo en la tabla, el campo debe ser de tipo varbinary:


Funcíón para encriptar contraseña:

CREATE FUNCTION [Navegacion].fun_usu_EncriptarContrasenia(@clave VARCHAR(50))
RETURNS VarBinary(8000)
AS
BEGIN
    DECLARE @pass AS VarBinary(8000)
    ------------------------------------
    ------------------------------------
    SET @pass = ENCRYPTBYPASSPHRASE('Encript0110',@clave)-- Encript0110 es la llave para cifrar el campo.
    ------------------------------------
    ------------------------------------
    RETURN @pass
END

Ejemplo: 
INSERT INTO [Navegacion].[nav_usuario] ([id_perfil], [nombre], [contrasenia], [activo], [id_personal])
 VALUES (1, 'ismael',  [Navegacion].fun_usu_EncriptarContrasenia('Ismael10'), 'True', 5);
Resultado: 


Funcíón para desencriptar contraseña:

CREATE FUNCTION [Navegacion].func_usu_DesencriptarContrasenia(@clave VARBINARY(8000))
RETURNS VARCHAR(50)
AS
BEGIN
    DECLARE @pass AS VARCHAR(25)
    ------------------------------------
     --Se descifra el campo aplicandole la misma llave con la que se cifro Encript0110
    SET @pass = DECRYPTBYPASSPHRASE('Encript0110',@clave)
    ------------------------------------
    ------------------------------------
    RETURN @pass
END



Ejemplo: 
 SELECT navUsu.id_perfil, navUsu.nombre,
 Navegacion.func_usu_DesencriptarContrasenia(navUsu.contrasenia) as contrasenia
 FROM Navegacion.nav_usuario as navUsu 
 where navUsu.nombre = 'ismael'

Resultado: 



Sql Server ¿Por qué utilizar Tablas Temporales Locales, Globales o Variables de Tabla?


Tablas Temporales.
Las tablas temporales son consideradas tablas regulares, y estas se almacenan automáticamente en la base de datos de tempdb.
Las tablas temporales se pueden usar en los siguientes escenarios:
Como alternativa a los cursores: por ejemplo, en lugar de utilizar un cursor de Transact-SQL para recorrer un conjunto de resultados y realizar tareas basadas en cada fila, en su lugar puede utilizar una tabla temporal. Usando un bucle WHILE, puede recorrer cada fila de la tabla y realizar la acción de la fila especificada, posteriormente debe eliminar la fila de la tabla temporal.
Como almacenamiento incremental de conjuntos de resultados: Por ejemplo, imaginemos que tiene una sola consulta SELECT que realiza una combinación “JOIN”con diez tablas. A veces las consultas con varias combinaciones “JOINS” pueden funcionar de manera incorrecta. Una técnica para intentar es la de fraccionar o fragmentar una consulta grande en consultas más pequeñas. Si usamos tablas temporales, podemos crear conjuntos de resultados intermedios basados en consultas de menor tamaño, en lugar de intentar ejecutar una consulta única que sea demasiado grande y de combinaciones múltiples “multi-joined”.
Como temporal en la sobrecarga baja de búsqueda de tabla: Por ejemplo, imagine que usted está utilizando una consulta que tarda varios segundos en ejecutarse, pero sólo muestra un pequeño conjunto de resultados, el cual desea utilizar en varias áreas de su procedimiento almacenado, pero cada vez que se llama se incurre en el tiempo de ejecución de la consulta general. Para resolver esto, puede ejecutar la consulta una sola vez en el procedimiento, llenando una tabla temporal, de esta manera se puede hacer referencia a la tabla temporal en varios lugares en su código, sin incurrir en una sobrecarga de resultados adicional.
Existen dos tipos de tablas temporales: Globales y Locales.
Las tablas temporales Locales se escriben anteponiendo el símbolo # y tablas temporales Globales con el doble símbolo ##.
Tablas temporales Locales.
Las tablas temporales Locales están disponibles para usarse por cada conexión actual del usuario que los cree.
Varias conexiones pueden crear una tabla temporal con mismo nombre, esto solo para para tablas temporales Locales sin causar conflictos. La representación interna de la tabla local tiene un nombre único, para no estar en conflicto con otras tablas temporales con el mismo nombre creado por otras conexiones en la tempdb.
Las tablas temporales locales son eliminadas con el comando DROP o se eliminan automáticamente de memoria cuando se cierra la conexión del usuario.
Creando la tabla temporal Local:
CREATE TABLE #ProductosResumen
( idProducto int NOT NULL PRIMARY KEY,
  nombre varchar(75) NULL,
  precio smallmoney NULL
);

Insertando datos en la tabla temporal global.
INSERT #ProductosResumen (idProducto, nombre , precio)
SELECT id,nombre, precio FROM dbo.DEMO_PRODUCTO
ORDER BY nombre;

Seleccionando los datos de la tabla temporal.
--Seleccionando los datos de la tabla temporal
SELECT * FROM #ProductosResumen; 

-- Resumen de precios de la tabla temporal
SELECT AVG(precio) FROM #ProductosResumen;

Resultado.
image
Eliminando la tabla.
-- Eliminando la tabla temporal
DROP TABLE #ProductosResumen;
Nota: Para que el ejemplo funcione deben de ejecutar en un solo bloque de instrucciones todo el código que coloque anteriormente. Para este caso yo llene mi tabla temporal con datos de una tabla que ya tenia creada en la base de datos, ustedes pueden utilizar un insert normal.
Tablas Temporales Globales.
Las tablas temporales Globales tienen un alcance diferente al de las tablas temporalesLocales. Una vez que una conexión crea una tabla temporal Global, cualquier usuario con permisos adecuados sobre la base de datos puede acceder a la tabla. A diferencia de tablas temporales Localesno se pueden crear versiones simultáneas de una tabla temporal Global, ya que esto generará un conflicto de nombres.
Las tablas temporales Globales de eliminan explícitamente de SQL Server ejecutandoDROP TABLE. También se eliminan automáticamente después de que se cierra la conexión que la creo, la tabla temporal Global no es referenciada por otras conexiones, pero es muy raro ver que se utilicen tablas temporales Globales en bases de datos en producción.
Es importante considerar cuando una tabla va o debe ser compartida a través de conexiones, se debe crear una tabla real, en lugar de una tabla temporal Global. No obstante, SQL Server ofrece esto como una opción.
Creando la tabla temporal Global:
--Creando la tabla temporal Global
CREATE TABLE ##Roles
( idRol int NOT NULL PRIMARY KEY,
  nombre varchar(30) NULL,
  activo bit NULL
);
Insertando y seleccionando datos de la tabla temporal global:
-- Insertando datos en la tabla temporal global
INSERT INTO ##Roles
VALUES(1,'Administrador',1),
      (2,'Supervisor',1),
      (3,'Programador',0)

-- Seleccionando los datos de la tabla temporal global
SELECT * FROM ##Roles;

Resultado:
image 
Eliminando la tabla temporal global desde la conexión original que la creo.
-- Eliminando la tabla temporal global
DROP TABLE    ##Roles;

Variables de Tabla.
Por otro lado tenemos las Variables de Tabla que son un tipo de datos que puede ser utilizados en un lote Transact-SQL (Batch), procedimiento almacenado o función; estas variables de tabla son creado y definidas de forma similar a una tabla, sólo con un alcance de vida estrictamente definido. Las Variables de tabla suelen ser buenos reemplazos de tablas temporales siempre y cuando el conjunto de datos es pequeño.
Razones para usar las variables de tabla:
  • Duración o alcance. La duración de la variable de tabla sólo vive durante la ejecución del lote, función, o procedimiento almacenado.
  • Tiempos de bloqueo más cortos. Por el estrecho alcance o tiempo de vida.
  • Menos re compilaciones cuando se usa en los procedimientos almacenados.
Como se menciono anteriormente, hay inconvenientes para utilizar las variables de tabla. El rendimiento de las variable de tabla se ve afectado cuando el resultado es demasiado grande o cuando los datos de la columna de cardinalidad son fundamentales para la optimización del proceso de consulta.
La sintaxis para crear una variable de tabla es similar a la de crear una tabla normal, se utiliza la palabra clave DECLARE y el nombre de tabla, anteponiendo el símbolo @:
DECLARE @TableName TABLE

(column_name <data_type> [ NULL | NOT NULL ] [ ,...n ] )
Creando una variable de tabla:
-- Creando la variable de tipo tabla.
DECLARE @EstatusUsuarios TABLE
( idEstatus int NOT NULL PRIMARY KEY,
  nombre varchar(30) NULL
)
Insertando y seleccionando datos de la variable tabla:
-- Insertando en la variable de tipo tabla.
INSERT INTO @EstatusUsuarios VALUES (1,'Activo'),
                                    (2,'Inactivo'),
                                    (3,'Bloqueado')

-- Consultando datos de la variable de tipo tabla.
SELECT * FROM @EstatusUsuarios;
 Al terminar la ejecución del batch o bloque de instrucciones se eliminara la variable tabla, o si colocamos una instrucción GO automáticamente se eliminara y no la podremos utilizar como los muestro en el siguiente ejempló, recuerde que los ejemplo para claridad los coloque separados, pero los debe de ejecutar completos como lo hago abajo para el caso de la variables de tabla:
-- Creando la variable de tipo tabla.
DECLARE @EstatusUsuarios TABLE
( idEstatus int NOT NULL PRIMARY KEY,
  nombre varchar(30) NULL
)

-- Insertando en la variable de tipo tabla.
INSERT INTO @EstatusUsuarios VALUES (1,'Activo'),
                                    (2,'Inactivo'),
                                    (3,'Bloqueado')

-- Consultando datos de la variable de tipo tabla.
SELECT * FROM @EstatusUsuarios;

-- Al ejecutarse el go o el bloque de instrucciones
--la variable tabla se eliminara auitomaticamente.
Go

SELECT * FROM @EstatusUsuarios;
 Como podrán notar en el primer select nos regreso:
image
Y para el segundo select:
imageEsto es por que como lo comente anteriormente el tiempo de vida de la variable tabla termina al ejecutarse el bloque de instrucciones, en este caso termino con el GO.
Cuando encontremos problemas de rendimiento, debemos de asegurarnos de probar todas las soluciones y alternativas, y no necesariamente asumir que una de las opciones (tablas Temporales) son menos deseables que otras (variables de tabla).

lunes, 24 de septiembre de 2012

Cambiar modo de autentificación SQL Server 2008


Configuración y creación de usuarios en SQL Server 2008
Este pequeño tutorial permite configurar la forma de autentificación de usuario en SQL Server 2008, de Autentificación de Windows a Autentificación de SQL Server.


 Fuente del tutorial por 

http://fabianbermeop.blogspot.com/2010/11/configuracion-y-creacion-de-usuarios-en.html

  • Ingresamos a SQL Server 2008 y nos aparecerá esta pantalla de inicio en donde debemos ingresar el “nombre del Servidor”, generalmente esta en blanco por lo que debemos ingresarlo, el server name es el nombre de nuestra PC en mayúsculas ejemplo JUAN-PC
  • el modo de autenticación lo dejamos por defecto “autenticación Windows” y clic “conectar”
1
  • damos clic derecho sobre el nombre del servidor y elegimos propiedades
2
  • nos dirigimos a la pestaña seguridad y cambias de modo autenticación de Windows ah “Autenticación de SQL Server”
3
  • ahora damos clic en aceptar y nos aparece una advertencia, “algunos cambios tendrán efectos cuando SQL Server sea reiniciado” y damos clic en “aceptar”
4
Creación de usuarios
  • para crear un usuario, en el menú lateral damos clic derecho sobre la pestaña “Seguridad” luego “nuevo” y a continuación “Usuario”
5
  • una vez que seleccionamos nuevo usuario, en la pestaña “General” escogemos “Autenticación de SQL Server”
  • damos un “nombre de inicio de sesión”
  • ingresamos “la contraseña” adecuada como por ejemplo “*.#admin6789” de tipo alfanumérico
  • y finalmente marcamos solo el checkbox que dice “Exigir directiva de contraseña”
6
  • nos dirigimos a la pestaña “Funciones del servidor” y seleccionamos “SYSADMIN” que otorga los privilegios de administrador al usuario que estamos creando, o seleccionamos tan solo las credenciales que necesitemos, y clic en “Aceptar”
7
 

  • una vez terminado el proceso anterior cerramos el SQL Server 2008 para configurar el motor de base de datos desde el “management”
  • nos vamos a “inicio, todos los programas, Microsoft SQL Server 2008, Herramientas de configuración y clic en administrador de configuración de SQL Server”
8
  • en la pantalla que se nos presenta, nos dirigimos al menú lateral seleccionamos “configuración de red de SQL Server”, doble clic en “Protocolos para MSSQLSERVER” y nos ubicamos sobre el ítem “Canalización por nombre” que se encuentra como deshabilitado
9
  • procedemos a dar doble clic sobre “Canalización por nombre” y en la pantalla que se presenta seleccionamos “si” en la opción habilitar
10
  • cuando damos clic en aceptar nos muestra un mensaje que nos dice “algunos cambios surtirán efecto una vez haya detenido y reiniciado el motor de base de datos”
11
  • para detener el motor de base de datos nos vamos a la pestaña “Servicio de SQL Server” y seleccionamos SQL SERVER(MSSQLSERVER) ahora damos clic sobre el “botón detener” ubicado en el menú superior
12
  • realizamos el mismo proceso anterior pero esta vez clic en el “botón iniciar” del menú superior para proceder a reiniciar nuestro SERVER, una vez completado cerramos el administrador
13

  • para finalizar, abrimos el SQL Server 2008 y cambios la forma de autentificación elegimos “Autenticación de SQL Server y debajo las “credenciales del usuario” que creamos al inicio y entraremos normalmente en SQL Server 2008.
14
es todo lo que necesitamos para realizar una arquitectura cliente servidor, y manejar usuarios en SQL Server 2008, espero les sirve de mucho

Expresión regular para validar contraseña de usuario

Esta expresión regular limita al usuario ingresar una contraseña cumpliendo con ciertos estándares o políticas de seguridad, como son letras minúscula, mayúsculas, digitos y caracteres especiales. 
En este ejemplo la función recibe como parámetro la cadena de texto a validar y devuelve True si cumple con la expresión regular (Entre 7 a 30 caractéres, al menos que contenga un letra minúscula, una mayúscula y un dígito.), de lo contrario retorna False.

En VB:
_______________________________________________________________________________________
Importar la libreria

 Imports System.Text.RegularExpressions


 Public Function ValidarContraseniaUsuario(ByVal contraseniaUsuario As String) As Boolean
        Dim sPatternmail As String = "^(?!.*(.)\1{3})((?=.*[\d])(?=.*[a-z])(?=.*[A-Z])|(?=.*[a-z])(?=.*[A-Z])(?=.*[^\w\d\s])|(?=.*[\d])(?=.*[A-Z])(?=.*[^\w\d\s])|(?=.*[\d])(?=.*[a-z])(?=.*[^\w\d\s])).{7,30}$"
        Dim validar As Boolean = System.Text.RegularExpressions.Regex.IsMatch(contraseniaUsuario, sPatternmail)
        Return validar
    End Function

En C#:
_______________________________________________________________________________________

Using System.Text.RegularExpressions

public bool ValidarContraseniaUsuario(string contraseniaUsuario)
{
 String sPatternmail = "^(?!.*(.)\1{3})((?=.*[\d])(?=.*[a-z])(?=.*[A-Z])|(?=.*[a-z])(?=.*[A-Z])(?=.*[^\w\d\s])|(?=.*[\d])(?=.*[A-Z])(?=.*[^\w\d\s])|(?=.*[\d])(?=.*[a-z])(?=.*[^\w\d\s])).{7,30}$"
bool validar = System.Text.RegularExpressions.Regex.IsMatch(contraseniaUsuario, sPatternmail);
return validar;
}

miércoles, 19 de septiembre de 2012

Convertir cadena de texto en fecha, Varchar To DateTime SQL


-- SQL Server string to date / datetime conversion - datetime string format sql server
-- MSSQL string to datetime conversion - convert char to date - convert varchar to date
-- Subtract 100 from style number (format) for yy instead yyyy (or ccyy with century)
SELECT convert(datetime, 'Oct 23 2012 11:01AM', 100) -- mon dd yyyy hh:mmAM (or PM)
SELECT convert(datetime, 'Oct 23 2012 11:01AM') -- 2012-10-23 11:01:00.000

-- Without century (yy) string date conversion - convert string to datetime function
SELECT convert(datetime, 'Oct 23 12 11:01AM', 0) -- mon dd yy hh:mmAM (or PM)
SELECT convert(datetime, 'Oct 23 12 11:01AM') -- 2012-10-23 11:01:00.000

-- Convert string to datetime sql - convert string to date sql - sql dates format
-- T-SQL convert string to datetime - SQL Server convert string to date
SELECT convert(datetime, '10/23/2016', 101) -- mm/dd/yyyy
SELECT convert(datetime, '2016.10.23', 102) -- yyyy.mm.dd ANSI date with century
SELECT convert(datetime, '23/10/2016', 103) -- dd/mm/yyyy
SELECT convert(datetime, '23.10.2016', 104) -- dd.mm.yyyy
SELECT convert(datetime, '23-10-2016', 105) -- dd-mm-yyyy
-- mon types are nondeterministic conversions, dependent on language setting
SELECT convert(datetime, '23 OCT 2016', 106) -- dd mon yyyy
SELECT convert(datetime, 'Oct 23, 2016', 107) -- mon dd, yyyy
-- 2016-10-23 00:00:00.000
SELECT convert(datetime, '20:10:44', 108) -- hh:mm:ss
-- 1900-01-01 20:10:44.000

-- mon dd yyyy hh:mm:ss:mmmAM (or PM) - sql time format - SQL Server datetime format
SELECT convert(datetime, 'Oct 23 2016 11:02:44:013AM', 109)
-- 2016-10-23 11:02:44.013
SELECT convert(datetime, '10-23-2016', 110) -- mm-dd-yyyy
SELECT convert(datetime, '2016/10/23', 111) -- yyyy/mm/dd
-- YYYYMMDD ISO date format works at any language setting - international standard
SELECT convert(datetime, '20161023')
SELECT convert(datetime, '20161023', 112) -- ISO yyyymmdd
-- 2016-10-23 00:00:00.000
SELECT convert(datetime, '23 Oct 2016 11:02:07:577', 113) -- dd mon yyyy hh:mm:ss:mmm
-- 2016-10-23 11:02:07.577
SELECT convert(datetime, '20:10:25:300', 114) -- hh:mm:ss:mmm(24h)
-- 1900-01-01 20:10:25.300
SELECT convert(datetime, '2016-10-23 20:44:11', 120) -- yyyy-mm-dd hh:mm:ss(24h)
-- 2016-10-23 20:44:11.000
SELECT convert(datetime, '2016-10-23 20:44:11.500', 121) -- yyyy-mm-dd hh:mm:ss.mmm
-- 2016-10-23 20:44:11.500

-- Style 126 is ISO 8601 format: international standard - works with any language setting
SELECT convert(datetime, '2008-10-23T18:52:47.513', 126) -- yyyy-mm-ddThh:mm:ss(.mmm)
-- 2008-10-23 18:52:47.513
SELECT convert(datetime, N'23 شوال 1429  6:52:47:513PM', 130) -- Islamic/Hijri date
SELECT convert(datetime, '23/10/1429  6:52:47:513PM',    131) -- Islamic/Hijri date

-- Convert DDMMYYYY format to datetime - sql server to date / datetime
SELECT convert(datetime, STUFF(STUFF('31012016',3,0,'-'),6,0,'-'), 105)
-- 2016-01-31 00:00:00.000
-- SQL Server T-SQL string to datetime conversion without century - some exceptions
-- nondeterministic means language setting dependent such as Mar/Mär/mars/márc
SELECT convert(datetime, 'Oct 23 16 11:02:44AM') -- Default
SELECT convert(datetime, '10/23/16', 1) -- mm/dd/yy U.S.
SELECT convert(datetime, '16.10.23', 2) -- yy.mm.dd ANSI
SELECT convert(datetime, '23/10/16', 3) -- dd/mm/yy UK/FR
SELECT convert(datetime, '23.10.16', 4) -- dd.mm.yy German
SELECT convert(datetime, '23-10-16', 5) -- dd-mm-yy Italian
SELECT convert(datetime, '23 OCT 16', 6) -- dd mon yy non-det.
SELECT convert(datetime, 'Oct 23, 16', 7) -- mon dd, yy non-det.
SELECT convert(datetime, '20:10:44', 8) -- hh:mm:ss
SELECT convert(datetime, 'Oct 23 16 11:02:44:013AM', 9) -- Default with msec
SELECT convert(datetime, '10-23-16', 10) -- mm-dd-yy U.S.
SELECT convert(datetime, '16/10/23', 11) -- yy/mm/dd Japan
SELECT convert(datetime, '161023', 12) -- yymmdd ISO
SELECT convert(datetime, '23 Oct 16 11:02:07:577', 13) -- dd mon yy hh:mm:ss:mmm EU dflt
SELECT convert(datetime, '20:10:25:300', 14) -- hh:mm:ss:mmm(24h)
SELECT convert(datetime, '2016-10-23 20:44:11',20) -- yyyy-mm-dd hh:mm:ss(24h) ODBC can.
SELECT convert(datetime, '2016-10-23 20:44:11.500', 21)-- yyyy-mm-dd hh:mm:ss.mmm ODBC
------------
-- SQL Datetime Data Type: Combine date & time string into datetime - sql hh mm ss
-- String to datetime - mssql datetime - sql convert date - sql concatenate string
DECLARE @DateTimeValue varchar(32), @DateValue char(8), @TimeValue char(6)

SELECT @DateValue = '20120718',
       @TimeValue = '211920'
SELECT @DateTimeValue =
convert(varchar, convert(datetime, @DateValue), 111)
+ ' ' + substring(@TimeValue, 1, 2)
+ ':' + substring(@TimeValue, 3, 2)
+ ':' + substring(@TimeValue, 5, 2)
SELECT
DateInput = @DateValue, TimeInput = @TimeValue,
DateTimeOutput = @DateTimeValue;
/*
DateInput   TimeInput   DateTimeOutput
20120718    211920      2012/07/18 21:19:20 */