Trabajando con Delphi XE

SQL Server - Campos Identity e insertar Blob o Imagen

2012-08-19T21:52:00.000+01:00

Si necesitáis hacer inserciones de documentos e imágenes mediante código SQL y si tras una inserción necesitais saber el código generado mediante Identity por SQL Server, la opción segura es la siguiente y se trata de usar una nueva función disponible desde SQL Server 2005.

Paso 1. Crear un Procedimiento (Procedure) en la base de datos. Siempre recomiendo SQL Manager Lite for SQL Server que es gratuito, es muy sencillo de usar y es el mejor.

Paso 2. Crear un procedimiento almacenado (Store Procedure) en Delphi que lo ejecuta y recibe el valor.

PASO 1.
Recordad que para simplificar tenemos una tabla llamada documentos.
A este procedimiento le pasamos los parámetros de entrada, entre ellos uno de imagen (image en SQL Server y Blob en Delphi)
Tiene como parámetro de salida: CodNuevo que será el código que se la base de datos habrá generado de forma automática.

CREATE PROCEDURE dbo.InsertarDocumento
@Descripcion varchar(200),
@Extension varchar(5),
@NombreArchivoOriginal varchar(200),
@Fichero image,
@Revision varchar(30),
@TamañoKB int,
@CodNuevo int output

AS
BEGIN
  /* Procedure body */

DECLARE @FILAS_INSERTADAS TABLE
(CodDocumento int)

INSERT INTO Documentos (
Descripcion,
Extension,
NombreArchivoOriginal,
Fichero,
Revision,
TamañoKB )

OUTPUT INSERTED.CodDocumento INTO @FILAS_INSERTADAS

VALUES (
@Descripcion,
@Extension,
@NombreArchivoOriginal,
@Fichero,
@Revision,
@TamañoKB )

SELECT @CodNuevo = CodDocumento FROM @FILAS_INSERTADAS

END

PASO 2.
Creamos en Delphi un componente TSQLDataSet que llamamos SQL_Proc_InsertarDocumento
Le ponemos las propiedades
- conexión en su parámetro SQLConnection
- CommandType a ctStoredProc
- CommandText entonces se desplegará una lista donde deberá estar el procedimiento 'InsertarDocumento'

Una vez hecho eso podremos ver los parámetros que se generan automáticamente en Params

Luego ponemos el código pasando los parámetros de entrada y recibiendo el de salida en Result.
Lo mejor para esto es crear una función, pero para simplificar lo pongo con un ejemplo directo.

if SQL_Proc_InsertarDocumento.Active then
SQL_Proc_InsertarDocumento.Active := FALSE;

SQL_Proc_InsertarDocumento.ParamByName('@Descripcion').Value := 'Prueba1';

SQL_Proc_InsertarDocumento.ParamByName('@Extension').Value := 'PDF';

Fichero := 'c:\prueba.pdf';

SQL_Proc_InsertarDocumento.ParamByName('@NombreArchivoOriginal').Value:= Fichero;
SQL_Proc_InsertarDocumento.ParamByName('@Fichero').LoadFromFile(Fichero, ftBlob);

SQL_Proc_InsertarDocumento.ParamByName('@Revision').Value := '';

SQL_Proc_InsertarDocumento.ParamByName('@TamañoKb').Value := 128;

SQL_Proc_InsertarDocumento.ExecSQL(FALSE);

Result := SQL_Proc_InsertarDocumento.ParamByName('@CodNuevo').Value;

SQL_Proc_InsertarDocumento.Active := FALSE;

Comprobar si una ventana está abierta

2012-08-12T20:39:00.000+01:00

Si dentro de nuestra aplicación no queremos que una ventana se abra más de una vez, nos bastará con comprobar antes de crearla si ya está abierta.

Esta sencilla función nos comprueba si ya está abierta y en caso de estarlo la activa. Si estuviera minimizada la restaura.

En este caso se le pasa como parámetro la clase de la ventana. Ese valor lo podéis coger de la declaración de vuestra ventana. Aquí lo selecciono en naranja de la definición de un Tform básico.

var
Form1: TForm1;

implementation
{$R *.dfm}
end.

La función es la siguiente.

function VentanaAbierta (Ventana:TClass): Boolean;
var i:integer;
nada:TClass;
f:Tform;
begin
result := False;
for i := Screen.FormCount-1 downto 0 do
  begin
f:= Screen.Forms[i];
  if F.ClassType = Ventana then
begin
if F.WindowState = wsMinimized then
F.WindowState := WsNormal;
F.BringToFront;
result := TRUE;
break;
end;
  end;
end;

ERROR: Se excedió la capacidad de transacciones

2012-08-11T00:18:00.000+01:00

Trabajando con Delphi XE y XE2 y SQL Server 2008 Express, me salió el siguiente error:

"No se puede crear una transacción, se excedió la capacidad"

El problema viene de que hay o parece haber muchas conexiones abiertas simultáneamente sobre una TSQLConnection.

Aunque en la ayuda nos dice que puede provenir de que la base de datos pone un límite de conexiones, no era mi caso, ya que consultando la propiedad TSQLConnection.MaxStmtsPerConn veo que pone 0, lo que quiere decir que no hay limite.

Por si acaso, y no está de más, antes de abrir el TSQLConnection.AutoClone = TRUE, lo que nos previene de este tipo de problemas si topásemos con una base de datos que si pone límites.

La solución es:

- En modo de diseño, en el módulo de datos (que es donde supongo estáis poniendo los componentes)

- Los TCLientDataSET y TSQLDataSet o más antiguamente los TSQLQuery y TSQLTable poner su propiedad Active=FALSE.

- También a TSQLConnection.Active = FALSE.

- Luego, en cada ventana que el usuario cierra en ejecución, cerrad las tablas que se hayan abierto.

Cifrar - Descifrar

2012-08-04T21:15:00.001+01:00

Cuando se quiera descifrar y cifrar ya sean cadenas de texto, ficheros o stream, he encontrado una gran utilidad que no usa ninguna librería externa y sin ningún tipo de complicación.

Se trata del component DCPcrypt de David Barton que está de lo más actualizado aunque pueda no parecerlo.

Como siempre, mostraré los pasos uno a uno para que sea aún más sencillo.
1) Descargar el componente más actualizado que vale para Delphi XE y XE2.
2) Descomprimir en una carpeta.
3) Desde Delphi ir a "File - Open" y elegir el archivo DCPdelphi6.dpk
(aunque pueda parecer que es para Delphi 6, está actualizado y funciona perfectamente)
4) Compilar e Instalar: Pulsando el botón derecho sobre DCPdelphi6.bpl, primero elegir Compile y luego Install

5) Aparecerán entonces dos nuevas paletas, aunque no en la práctica sólo nos servirán para que rellenen automáticamente el uses

6) Ejemplo práctico: Una cadena de texto combinando Rijndael con Sha512.

Añadir al uses:

uses DCPcrypt2, DCPblockciphers, DCPrijndael, DCPrc4, DCPsha512;

function TForm1.Cifrar(Texto, Clave: AnsiString): String;
  var
Cipher: TDCP_Rijndael;
  begin
Cipher:= TDCP_Rijndael.Create(Self);
Cipher.InitStr(Clave,TDCP_sha512);
result := Cipher.EncryptString(Texto);
Cipher.Burn;
Cipher.Free;
  end;

  function TForm1.Descifrar(Texto, Clave: AnsiString): String;
  var
Cipher: TDCP_Rijndael;
  begin
Cipher:= TDCP_Rijndael.Create(Self);
Cipher.InitStr(Clave,TDCP_sha512);
result := Cipher.DecryptString(Texto);
Cipher.Burn;
Cipher.Free;
  end;
Y listo.

Para saber más sobre el componente para cifrar archivos o trabajar con stream abrid el archivo que index.html dentro de la carpeta Docs en la carpeta donde habéis descomprimido el componente.

Ahh, un detalle: si os gusta el componente y queréis levantar la moral al amigo David para que continué con el proyecto, podéis escribirle un correo al menos para saludarlo.

Acelerar las operaciones multiples con una base de datos

2012-03-31T01:11:00.002+01:00

En muchas ocasiones, hay que realizar operaciones con bases de datos que implican cientos o miles de inserciones, borrados o modificaciones.

Cuando las ejecutamos vemos que la aplicación se queda un largo tiempo realizándolas, dejando a nuestro cliente al borde del ataque al corazón y con enormes ganas de insularnos.

Aunque hay otros métodos más sofisticados, el que voy a poner no implica cambios en el código, tan sólo añadir unas líneas de código.

Recordar que este código sustituye al antiguo StartTransaction, Transaccion.Rollback y Transaction.Commit

En el uses añadimos las unidades: SqlExpr y DBXCommon.

En la función que realiza el proceso, definimos una variable:

var DBXTransaction:TDBXTransaction;

Luego añadimos el siguiente código:

DBXTransaction := SQLConnection1.BeginTransaction(TDBXIsolations.SnapShot);
try

    // Aquí estará nuestro actual código que hace todas las operaciones.

    SQLConnection1.CommitFreeAndNil(DBXTransaction);

  except

    SQLConnection1.RollBackFreeAndNil(DBXTransaction);

  end;





En pruebas que he hecho, insertando unos 3500 registros en una base de datos local, y sólo añadiendo ese código, se ha reducido el tiempo casi en un 40%. En una base de datos a través de internet la mejora sería aún mayor.

Más adelante explicaré como mejorar aún más nuestras operaciones con las bases de datos.

Datos del PC: Nombre, IP y usuario

2012-03-25T02:45:00.000+01:00

Siempre es muy útil poder disponer de los datos relativos a la red del equipo en el que estamos ejecutando nuestra aplicación.
He englobado los principales datos en una única función para simplificar el proceso y así obtener:
- Nombre del PC
- Dirección IP local
- Nombre del usuario de Windows.

Recordad añadir al uses lo siguiente: WinInet, WinSock;

Para simplificar los parámetros he creado un tipo de datos que debeis poner después del uses

type TDatosPC = record
Nombre, IP, Usuario :String;
end;

Y esta es la función que nos devuelve los tres datos

procedure ObtenerDatosPC (var Datos:TDatosPC );
const LARGO_MAXIMO = 50;
var buffer:Array [0..LARGO_MAXIMO+1] of char;
Largo:Cardinal;
PuntHost: PHostEnt;
PuntIP: PAnsichar;
wVersionRequested: WORD;
wsaData: TWSAData;
begin
Largo := LARGO_MAXIMO +1;
Datos.Nombre := '';
If GetComputerName (buffer, Largo) then
Datos.Nombre := buffer;
Datos.Usuario := '';
if GetUserName(buffer, largo) then
Datos.Usuario := buffer;
wVersionRequested := MAKEWORD( 1, 1 );
WSAStartup( wVersionRequested, wsaData );
GetHostName( @buffer, LARGO_MAXIMO );
PuntHost := GetHostByName( @buffer );
PuntIP := iNet_ntoa( PInAddr( PuntHost^.h_addr_list^ )^ );
Datos.IP := PuntIP ;
WSACleanup;
end;

Efecto para mostrar/ocultar ventana

2012-03-24T00:45:00.000+00:00

Cuando tenemos que mostrar una ventana con datos de una o varias tablas podemos comprobar como se dibuja de forma lenta y creando efectos pocos agradables a la vista.

Para evitar esos desagradables efectos, pongo el siguiente ejemplo. Una función de lo más sencilla que permitirá que las ventanas aparezcan y desaparezcan con un bonito efecto visual.

Aunque cada uno lo pondrá a su gusto, el retardo suele estar bien con un valor de 10

Este efecto de DESAPARECER lo podéis poner en el evento OnClose y/o también en OnCloseQuery.

// Hace que una ventana desaparezca.

// El retardo es en milisegundos.
procedure DesaparecerVentana (Retardo:Integer; Ventana :TForm);
var
i : integer;
begin
Ventana.AlphaBlendValue := 255;
Ventana.AlphaBlend := TRUE;
for i := 255 downto 0 do
begin
Ventana.AlphaBlendValue := i;
Application.ProcessMessages;
sleep (Retardo);
end;
end;
Este efecto de APARECER lo podéis poner en el evento OnShow

NOTA IMPORTANTE: Si lo queréis hacer con la ventana principal de vuestra aplicación no lo pongais en el evento OnShow y haced lo siguiente:
1) Poned la propiedad visible a FALSE de la ventana principal
2) Entrad en project - View Source y después de la línea que pone: Application.CreateForm(TForm1, Form1); (o algo parecido)
escribid lo siguiente:

Form1.visible := TRUE;

AparecerVentana (10,Form1);

// Hace que una ventana aparezca.
// El retardo es en milisegundos.
procedure AparecerVentana (Retardo:Integer; Ventana :TForm);
var
i : integer;
begin
Ventana.AlphaBlendValue := 0;
Ventana.AlphaBlend := TRUE;
for i := 0 to 255 do
begin
Ventana.AlphaBlendValue := i;
Application.ProcessMessages;
sleep (Retardo);
end;
Ventana.AlphaBlend := FALSE;
end;

Nuevo libro sobre Delphi

2012-03-14T07:55:00.001+00:00

Por fin hay un nuevo libro sobre Delphi y en español.

No será como uno de los increíbles libros de Ian Marteens, pero no se puede elegir dada la situación.

Se titula "La Guía de Delphi" por Francisco Charte

Podéis buscarlo en la web de Danysoft o directamente en Libro de Delphi en Danysoft

Ejemplo: Aplicación con BASE DE DATOS de 3 de capas multihilo con DBX4 y Delphi XE - multi-threaded application with Database, Delphi XE and DataSnap DBX4

2012-03-08T17:35:00.001+00:00

Haremos un ejemplo de aplicación cliente servidor con BASE DE DATOS muy sencilla y lo explicaré lo más detallada posible.

Básicamente es la misma que la que ya escribí sin base de datos, simplemente añadiendo unos componentes. Por ello, escribo la misma y cuando haya que hacer cosas distintas lo pondré especificado con las etiquetas
PASO ADICIONAL PARA USAR BASES DE DATOS (...)
--- FIN PASO ADICIONAL PARA USAR BASES DE DATOS (...)

Esto es para aquellos que el resto del proceso lo tengan claro y no quieran leerlo de nuevo.

APLICACIÓN SERVIDOR

Paso 1 Servidor
Abrimos Delphi y vamos a File - New - Other .

Paso 2 Servidor
Ahora vamoa a New Item elegir "Delphi Projects" - "DataSnap Server" y hacer clic "DataSnap Server" y "OK"

Paso 3: Servidor
Tipo de Proyecto
Seleccionar:
VCL Forms Application: Si se quiere que el servidor tenga una o más ventanas (es nuestro ejemplo)
Console Applicaton: El servidor aparecerá como una consola de comandos.
Service application: Si queremos que nuestro servidor se ejecute como un servicio en Windows.

Elegimos y pulsamos NEXT

Paso 4: Servidor

Características del Servidor
- Protocols: TCP/IP para una aplicación estandar y HTTP sobre todo para aplicaciones web.
- Autenticación: Si queremos que en nuestro servidor se utilice algún tipo de identificación. No es la autenticación de una base de datos, es un nuevo sistema para proteger el código. No la marcamos
- Server Methods Class. Nos genera una unidad con dos ejemplos de como usar funciones para compartir con los clientes.
En nuestro ejemplo lo dejaremos todo con las opciones por defecto y pulsamos NEXT.

Paso 5: Servidor
Número de Puerto
Nos dejará elegir el número de puerto que usará nuestra aplicación.
Nos permitirá chequear si el puerto está en uso e incluso buscar uno libre.

Paso 6: Servidor
Clase de métodos de servidor
TComponent: Cuando queremos que el servidor sólo exponga funciones, sin bases de datos.
TDataModule: Si queremos que nuestro servidor exponga bases de datos a través de los TDataSetProviders
TDSServerModule: Es la versión más completa para bases de datos ya que nos implementa el interface IAppServer
Nosotros escogemos TDSServerModule y hacemos clic en Finish

Ya tenemos nuestra versión básica de Servidor
Ahora nos aparece el proyecto con las distintas forms creadas
ServerContainerUnit1: unidad para las características del servidor
ServerMethodsUnit1: almacena los métodos que exportará el servidor, es decir, los que la aplicación cliente podrá usar.
Unit1: nuestro form principal

Ahora retocamos algo nuestro servidor:
Vamos a ServerContainerUnit1.pas en la pestaña de "Diseño"

Al componente DSServer1 le ponemos la propiedad "AutoStart" a False, para así poder iniciar/parar el servidor de forma manual desde nuestro form principal.

La propiedad HideDsAdmin es útil cuando la aplicación está totalmente terminada porque si la ponemos a TRUE no serán visibles los métodos que el servidor publique. así desde otra aplicación cliente de otra persona no se podrían usar nuestros métodos. Pero en tiempo de desarrollo hay que dejarla a FALSE.

Luego en el componente DSServerClass, en el evento "On Get Class" vemos que el asistente ha creado el siguiente código:
PersistentClass := ServerMethodsUnit1.TServerMethods1;
Es la manera de decir dónde están las cosas que el servidor va a compartir.

MUY IMPORTANTE: anotar ese TServerMethods1 ya que lo vamos a necesitar en el lado del cliente a la hora de configurarlo.

El DSTCPServerTransport1 es donde configuramos el máximo hilos, el puerto, y una cosa muy importante: los filtros para el transporte de datos. De esto último hay un ejemplo de comprimir las transmisiones en este blog.

Luego en el componente DSServerClass1 ponemos la propiedad LifeCycle a session
Los tipos posibles son
Server: Un servidor para todos los clientes. El segundo que intenta acceder a un dato tiene que esperar.

Sesión. Cada cliente crea su servidor. Nadie espera salvo uno mismo si es multihilo. Guarda la memoria hasta que cierre sesión. Para iniciarse es mejor esta opción porque la Invocation puede hacer cosas que no esperamos.

Invocación. Mayor coste de proceso. No gasta memoria. No hay esperas. El problema que puede aparecer y que requiere de más atención es que como el TSQLConnection se cierra cuando no hay ningún acceso abierto, puede darse el caso de que las consultas nos devuelvan valores inesperados, como si acabásemos de entrar de nuevo.

La unidad ServerMethodUnit1

En la unidad ServerMethodsUnit1 ponemos todo lo que queremos que el servidor publique para los clientes: Funciones, TQuery, TTable, ...

Si son function o procedure y las creamos de forma automática con SHIFT-CTRL-C recodar que se habrán creado en la zona Private y entonces no serán publicadas en el servidor.
Recordar declarar function o procedure en el en Public.

Si en el asistente de servidor hemos marcado la casilla de "Sample Methods" veremos que estarán creadas dos funciones de ejemplo:

function TServerMethods1.EchoString(Value: string): string;
begin
Result := Value;
end;

function TServerMethods1.ReverseString(Value: string): string;
begin
Result := StrUtils.ReverseString(Value);
end;

Vamos a añadir nuestro ejemplo simple pero algo más útil: saber la hora que tiene el servidor.
Podría permitirnos sincronizar ordenadores o grabar en un registro la hora real del servidor y no la del pc desde donde lo ejecuta el cliente.

Function TServerMethods2.HoraEnServidor: TDateTime;
begin
result := now;
end;

PASO ADICIONAL PARA USAR BASES DE DATOS (1)
Ahora añadiremos nuestros componentes para la base de datos en el lado del servidor.
Es en la ServerMethodsUnit donde debemos poner nuestros componentes de la base de datos.
En la parte derecha de Delphi, hacemos clic en la pestaña "DataExplorer".
Buscamos nuestra base de datos, en mi caso dentro de Firebird, se llama CONEXIONDEMO.
Simplemente, la arrastramos hasta el form.

A continuación elegimos una tabla del DataExplorer, en mi caso, "Clientes" y simplemente la arrastramos hasta el form ServerMethodsUnit, así ya queda configurado nuestro TSLQDataSet. De forma manual, también podemos añadir otros , y suele ser lo más conveniente en una aplicación, los TSQLQuery.
Ahora, lo que nos falta el poner es el TDataSetProvider, uno por cada componente anterior, y cambiando su propiedad DataSet al valor apropidado, en nuestro caso inicial Clientes.

En este ejemplo, para simplificar, las conexiones, dataset y demás los dejamos conectados, para así, poder probar sin tener que poner código adicional.

Ahora añadiremos los campos de la tabla que hemos colocado. Hacemos clic con el botón secundario del ratón sobre el TSQLDataSet llamado Clientes y elegimos "Field Editor" y dentro de ese, hacemos clic sobre el botón secundario del ratón y elegimos "add all fields".

--- FIN PASO ADICIONAL PARA USAR BASES DE DATOS (1)

Ahora abrimos la unit1 y le ponemos un TButton con el caption "iniciar"

Añadimos al uses la unidad: ServerContainerUnit1;

Y en el evento "on click" del TButton ponemos:

procedure TForm1.Button1Click(Sender: TObject);
begin if ServerContainer1.DSServer1.started then
begin
ServerContainer1.DSServer1.Stop;
Button1.Caption := 'Iniciar';
end
else
begin
ServerContainer1.DSServer1.Start;
Button1.Caption := 'Parar';
end;
end;

Ahora grabamos todo el proyecto en una carpeta, mejor separando al servidor del cliente:
Proyecto\Servidor
Y grabamos el proyecto con el nombre "servidor"

MUY IMPORTANTE: ejecutamos el servidor en modo "sin depuración" haciendo clic con el botón secundario del ratón sobre el proyecto Servidor y eligiendo "Run Without Debugging", porque a la hora de configurar y ejecutar el cliente lo vamos a necesitar

Dado que hemos creado un servidor con inicio manual, recordar una vez ejecutado el servidor hacer clic sobre el botón iniciar del servidor para que esté totalmente operativo.

APLICACIÓN CLIENTE

Sobre el proyecto pulsamos el botón derecho del ratón y elegimos "Add New Project"

Hacemos clic sobre "Delphi Projects" y seleccionamos "VCL Form Application" y "OK"

RECORDAR:
- que el servidor tienen que estar ejecutándose e iniciado.
- El proyecto activo en Delphi (el que está en negrita a la derecha) sea el del cliente, porque de lo contrario lo que vamos a hacer a continuación lo pondrá en el proyecto del servidor y habremos hecho un lío.

Ahora vamos al menú "File", "new","Other", elegimos "Delphi Projects", luego "DataSnap Server" y "Data Snap Client Module"

Nos pedirá el tipo de servidor: Local o Remoto. La diferencia es que en el remoto pide nombre o IP del host y en el local no nos lo pide ya que pone "localhost"

Ahora nos pide el tipo de servidor: en nuestro caso será sólo con DataSnap stand alone server

Ahora nos pregunta que tipo de protocolo usaremos: en nuestro caso TCP/IP

Y ahora nos pide el puerto que le hemos puesto al servidor.
Es importante que el servidor se esté ejecutando, ya que de lo contrario no conectará y no nos dejará continuar.

Si lo hemos hecho bien, y pulsamos el botón "Test Connection" nos mostrará un mensaje de "test connection succeeded"

Y entonces podremos pulsar el botón "finish"

Ahora grabamos el nuevo proyecto como "cliente", quedándonos algo como lo siguiente:

Ahora en la unit ClientModuleUnit1 nos aparecerá un SQLConnection1. No debemos modificar nada de ese componente.

Añadimos DSProviderConnection y cambiamos lo siguiente:
propiedad Sqlconnection apuntando a SQLConnection1 (si no la hemos renombrado)
y lo más IMPORTANTE: la propiedad ServerClassName con TServerMethods1

IMPORTANTE: No es una propiedad con una lista desplegable ni nada parecido. Hay que escribirlo y te deja poner cualquier cosa, eso sí, si no está correcto no funcionará nada.

Es algo que expliqué en la parte del servidor y lo repito de nuevo:

En el componente DSServerClass de la unidad ServerContainerUnit1;, en el evento "On Get Class" vemos el siguiente código que se genera automáticamente con el asistente:
PersistentClass := ServerMethodsUnit1.TServerMethods1;

Luego ponemos un TSQLServerMethod y cambiamos
propiedad Sqlconnection apuntando a SQLConnection1

Ahora en propiedad ServerMethodName hacemos clic y si lo hemos hecho todo correcto y el servidor está funcionando, nos saldrá una lista con todas las funciones que el servidor está publicando.
En nuestro caso elegimos TServerMethods1.HoraEnServidor

Ahora hacemos doble clic en su propiedad Params y nos mostrará los parámetros de entrada salida del método elegido. En nuestro caso sólo tiene de salida por si lo queremos renombrar.

Y ya sólo nos queda dar utilidad a nuestro cliente, pidiendo la hora a nuestro servidor y mostrándola.

Ahora abrimos la unidad unit3
En la clausula uses añadimos: ClientModuleUnit1;

Ponemos un TButton

En el evento onclick del TButton ponemos

procedure TForm3.Button1Click(Sender: TObject);
begin
// Así sería si tuviese parámetros de entrada, lo pongo para que veais el funcionamiento de las llamadas.
// ClientModule1.SqlServerMethod1.ParamByName('LoQueSea').Text := 'ValorEnviado';

ClientModule1.SqlServerMethod1.ExecuteMethod;
Showmessage (FormatDateTime
('dd/mm/yy hh:nn',ClientModule1.SqlServerMethod1.ParamByName('ReturnParameter').Value));
end;

Y ya tenemos una aplicación cliente servidor.
Si están interesados también podemos hacer lo mismo pero con bases de datos que es algo más complejo pero más apasionante.

PASO ADICIONAL PARA USAR BASES DE DATOS (2)

En la unit ClientModuleUnit ponemos un componente DSProviderConnection y cambiamos sus propiedades:
- SQLConnection: apuntando a nuestro SQLConnection que está en este mismo form.
- LO MAS IMPORTANTE: (recordad paso 6 del servidor)
En la unit ServerContainerUnit nos aparece el código siguente:
PersistentClass := ServerMethodsUnit1.TServerMethods1;

Pues bien, en la propiedad ServerClassName: ponemos TServerMethods1
Esto se escribe a mano, no hay ninguna lista desplegable, para evitar errores tontos que nos pueden llevar
a un dolor de cabeza, mejor copia y pega.

No me cansaré de repetirlo: el servidor tiene que estar ejecutándose para cambiar las siguientes propiedades.

Ahora ya podemos añadir los ClientDataSet a nuestra tabla o consulta.
Primero debemos modificar la propiedad RemoteServer: que será el DsProviderConnection1
Luego modificamos la propiedad ProviderName apuntando a nuestra tabla o consulta, en nuestro caso DataSetProvider1

Recordad para simplificar, dejar todo conectado.
SQLConnection1.connected := TRUE;
SQLConnection1.connected := TRUE;
ClientDataSet1.Active := TRUE;

Ahora tan sólo vamos a la ventana principal de nuestra aplicación cliente (o a cualquier otra ventana), en nuestro ejemplo Unit3:

Ponemos en el USES de Unit3 a ClientModuleUnit1.
Ahora ponemos un DataSource en Unit3, y cambiamos su propiedad DataSet a ClientModule1.ClientDataSet1.

Luego ponemos una DBGrid. Cambiamos su propiedad DataSource a nuestro DataSource1 y si hemos dejado todo conectado nos aparecerán los datos inmediatamente, sin tener que ejecutar la aplicación.

Y con eso hemos terminado esta explicación. Obviamente, esto se puede complicar mucho más, pero ya debéis tener claro los conceptos básicos.

NOTA
Sobre todo en el caso de consultas que deseamos pasarle parámetros para mostrar resultados diferentes en nuestra DbGrid, recordad que no es conveniente usar CommandText. Básicamente, porque con ello hacemos vulnerable a nuestra aplicación a ataques de SQL.

Es mejor, crear una función con parámetros en el servidor con la que podamos abrir y cerrar la consulta desde nuestra aplicación cliente SIN tener que enviar el código SQL a través de la red.
Es usar los TSqlServerMethod1 como ya he explicado.

Si hay dudas de cómo hacer esto, me lo hacéis saber y escribo sobre ello.

--- FIN PASO ADICIONAL PARA USAR BASES DE DATOS (2)

Gestores de bases de datos

2012-01-21T20:24:00.000+00:00

Aquí os dejo un enlace para la descarga de las versiones gratuitas del mejor gestor de bases de datos que conozco: SQL Manager.
Hay una versión para cada base de datos y es gratis.
Esta versión gratuita tiene todo lo que necesitas: tablas, procedimientos, Triggers, Exceptions, Generadores, etc.
Es muy sencillo de usar y con una gran potencia.
SQL Manager LITE

Usar JPG y PNG transparentes con canal Alpha en Delphi XE

2011-11-27T13:25:00.001+00:00

Para usar imágenes PNG (con canal Alpha), JPG, etc en Delphi no es necesario instalar componentes adicionales.

La forma en que funcione correctamentes usar el componente TImageList, y luego desde nuestro TButton o desde cualquier otro, usar esas imágenes contenidas en el TImageList.

Actualmente eso sólo es válido para casi todos los componentes como TButton, pero no sirve para unos pocos como TSpeedButton.

Añadimos un TImageList y recordar que todas las imágenes contenidas "deben" tener las mismas dimensiones en pixels, de lo contrario pueden ocurrir efectos indeseados.
Si tenemos distintos tamaños en las imágenes, sólo hay que poner un TImageList por cada tipo de tamaño.

Antes de añadir las imágenes debemos cambiar unas propiedades del TImageList:
- Heigth y Width: con las dimensiones exactas (en pixels) de las imágenes que va a contener.
- Para activar el canal Alpha en los PNG hay que cambiar las siguientes propiedades:
- DrawingStyle: dsTransparent
- ColorDepth: cd32Bit

Y ahora ya podemos añadir las imágenes que deseemos dentro del TImageList y nos saldrán perfectas en nuestros componentes.

Comparar dos archivos de código fuente

2011-11-19T19:55:00.001+00:00

Si en algún momento necesitas comparar dos archivos de código fuente para observar los cambios, os recuerdo un programa magnífico y gratuito: WinMerge.(http://winmerge.org/downloads/)

No sólo sirve para Delphi, compara cualquier tipo de archivo de tipo texto (no binarios).

MS Word: Word no puede completar guardar debido a un error de permiso de archivo

2011-11-17T00:46:00.001+00:00

Aunque este blog es de Delphi, haré una excepción - try .. except, je je - para los casos en los veo que la gente tiene un problema al que nadie le da una solución.

Para todos aquellos a los que al grabar un archivo con Word les sale el siguiente mensaje
"Word no puede completar guardar debido a un error de permiso de archivo",
y si ya están hartos de no obtener respuesta, pues la solución es la siguiente:

En Word 2003: Ir al menú "herramientas", "opciones", pestaña "Guardar", sólo hay que desmarcar la casilla "Permitir guardar en segundo plano"

En el resto de versiones, puede cambiar un poco pero hay poca diferencia para encontrarlo.

Somos dinosaurios?

2011-11-14T00:41:00.001+00:00

Hasta hace unos años estaba internet inundado de ejemplos de todo tipo sobre Delphi.

Eso ha desaparecido y lo único que se escribe sobre Delphi es la publicidad que expone Embarcadero, una y otra vez.

Actualmente páginas con código fuente interesante y "fresco" prácticamente no existen.

He intentado poner mi granito de arena en este sentido, y a la vez que yo enseño lo poco que sé, esperaba vosotros también compartierais con los demás lo que sabéis, o bien poniendo código en esta blog, o poniendo enlaces a vuestros blogs o web, o al menos dejando mensajes, para que los demás supiéramos que existís.

Pero en lugar de conseguir que este blog sea un punto de encuentro para todos, lo que se ha hecho es entrar en este blog, aprender y/o copiar lo que se pueda y salir sin decir ni adiós.

Eso, no sólo en Delphi, sino en el resto de actividades de nuestras vidas no es como deberían ser las cosas.

Creo que todos deberíamos reflexionar porque este sistema de lo mio es mío y lo de los demás también es mío no nos lleva a un buen resultado ni con Delphi ni con nada.

O todos ponemos nuestro granito de arena para levantar Delphi y compartir todo tipo de código, o tanto Delphi como nosotros mismos estamos abocados a la desaparición, cual dinosaurios.

La gran revolución de Delphi fue el innumerable código que había sobre cualquier tema, o eso regresa o nos limitaremos a mantener nuestras viejas aplicaciones hechas en Delphi 7 hasta que un día no den más de sí y en ese momento se acabará todo.

Escribid, compartid, haceos ver, tanto para mi como para el resto del mundo. Compartir lo que sabéis aunque os parezca que os quedaréis vacíos, lo que os pasará es que os será devuelto con creces a través de otras decenas de código que otros también compartirán.

Espero que mi reflexión os haga pensar.

Ventana de Clave de acceso o de Splash - access key window

2011-10-12T19:11:00.000+01:00

Si necesitas poner una ventana en tu aplicación para solicitar una clave de acceso, incluso una de splash este es un buen método.

Abre el código del proyecto (menú Project - View Source) y pon lo siguiente:

begin
Application.Initialize;
// Esto es de XE, y te permite ocultar tu aplicación en la barra de tareas.
Application.MainFormOnTaskbar := True;

// Creamos la ventana dónde se pedirá la clave
Application.CreateForm(TPtClave, PtClave);

// Creamos, si lo vamos a usar, el módulo de datos
Application.CreateForm(TClientModule1, ClientModule1);

// Abrimos la ventana de Clave en forma Modal
PtClave.ShowModal;

// Guardamos el resultado de nuestra ventana Clave en la variable Rdo
// La ventana nos devolverá MrOK si se identificó correctamente Rdo := PtClave.ModalResult;

// Dado que vamos a liberar la pantalla clave, guardamos los datos de usuario que los podemos necesitar en nuestra apliación principal.
UsuarioNombre := PtClave.EditUsuario.Text;

// Liberamos la ventana de Clave
PtClave.Free;

   // si todo fue bien, creamos nuestra aplicación
if Rdo = MrOK then
  begin
Application.CreateForm(TPtPrincipal, PtPrincipal);

// le pasamos a la aplicación el dato del usuario identificado, para mostrarlo en un panel por ejemplo.
  PtPrincipal.PanelUsuario.caption := UsuarioNombre;
Application.Run;
  end;

end.

Controlar la pantalla y detener la aplicación - Control the display and delay the application

2011-10-01T13:31:00.000+01:00

Con este ejemplo vemos dos temas:
- Controlar la pantalla de nuestro ordenador.
- Detener nuestra aplicación durante un tiempo, que es un tema del que parece haber muchas dudas.

Poner un TButton en el Form y poco más.

procedure TForm1.Button1Click(Sender: TObject);
begin
// Poner en standby la pantalla
TareasConPantalla (1);
// Pausamos 5 segundos

sleep (5*1000);
// Apagar la pantalla
TareasConPantalla (2);
// Pausamos 5 segundos

sleep (5*1000);
// Encender la pantalla
TareasConPantalla (-1);
end;
procedure TForm1.TareasConPantalla (Tarea:integer);
begin
SendMessage(Application.Handle, WM_SYSCOMMAND, SC_MONITORPOWER, Tarea);
end;

Sincronizar hora - synchronize time - Delphi XE

2011-10-01T13:05:00.000+01:00

Para aquellos que quieran sincronizar la hora con un servidor horario, esta es una buena fórmula.

Útil para ponerlo en el inicio de Windows en todos los ordenadores de una red y así tenerlos todos con la misma hora.

La sincronización, al contrario de la que efectua Windows, es instantánea.
Para mostrar algo más como se trabaja con las fechas y para darle algo más de utilidad, que tiene muchas, he puesto que si el desface supera los 5 minutos, que muestre un mensaje.

Espero que os sea de utilidad.

Antes de nada, en nuestro Form:
- Añadir un componente TIdSNTP
- Añadir al uses: Dateutils

procedure SincronizarHora;
var

SystemTimeIni, SystemTimeFin: TSystemTime;
SegundosDeDiferencia:longInt;
ServidorHorario:String;
MaxMinutosDesface:integer;
begin
// VARIABLES A DEFINIR
ServidorHorario := 'hora.rediris.es' ;
MaxMinutosDesface := 5;
try
GetLocalTime(SystemTimeIni);
idSNTP1.Active := False;
idSNTP1.Host := ServidorHorario;
idSNTP1.Active := True;
idSNTP1.Active := False;
if idSNTP1.DateTime <> 0 then
begin
// Convertimos la hora devuelta por idSNTO a hora del sistema
DateTimeToSystemTime(idSNTP1.DateTime,SystemTimeFin);
// Ponemos en hora el sistema
SetLocalTime(SystemTimeFin);
// Indicarle a Windows el cambio
PostMessage(HWND_BROADCAST,WM_TIMECHANGE,0,0);
// Calculamos el tiempo de desface
SegundosDeDiferencia := MilliSecondsBetween (SystemTimeToDateTime (SystemTimeFin),

SystemTimeToDateTime (SystemTimeIni)) div 1000;
// Si es superior a los minutos estimados, mostramos un mensaje.
if SegundosDeDiferencia > (60 * MaxMinutosDesface) then
showmessage ('Revisar pila interna del ordenador');
end; // END IF
except
on E : Exception do
ShowMessage(' Error al sincronizar hora: '+chr(13)+E.Message);
end; // ENND TRY
end;

Hay alguien ahí??

2011-09-25T01:07:00.000+01:00

Si os parece interesante el contenido del blog os agradecería dos cosas:
- Que escribieseis vuestros comentarios.
- y que cuando os fuera posible hicierais clic sobre los anunciantes que también son importantes.

Ambas son formas de mantener viva la ilusión por continuar con este blog empleando horas de sueño para que no se apague la llama de Delphi y ser de utilidad a compañeros.

Gracias a todos.

Crear Base de Datos - DataBase Create

2011-09-25T01:01:00.000+01:00

Nuestro siguiente ejemplo será una aplicación Cliente/Servidor con Firebird como motor de la base de datos, y para ello vamos a necesitar previamente una base de datos con algunos datos.

Para aquellos que no estén habituados con este tema, les explico brevemente como crear una base de datos con una tabla, un ejemplo muy básico, que luego podremos ir ampliando tan sólo repitiendo algunos de los pasos que se muestran a continuación.

Cambiar Firebird por otra es un tema muy simple, aunque en mi opinión, ya es hora de que relancemos Firebird como la magnífica base de datos que es.

Yo uso un magnífico programa que te permite usar características avanzadas de Firebird sin apenas conocimientos.
Se llama SQL Manager Lite 2008. Funciona perfectamente con Firebird 2.5 y es GRATUITO.
Si no lo podeis conseguir avisadme y pongo un enlace para su descarga, porque el fabricante ya no saca más esta versión gratuita.

En nuestro caso crearemos una base de datos llamada Demo.fdb en Unicode (UTF8)

Si no tenéis un programa como este, lo mejor es ejecutar el siguiente script en vuestra base de datos:

CREATE DATABASE '127.0.0.1/gds_db:C:\Demo\Demo.fdb'
USER 'SYSDBA'
PASSWORD 'masterkey'
PAGE_SIZE = 4096
DEFAULT CHARACTER SET UTF8

Es importante usar UTF8 (unicode), cualquier otra cosa es algo del pasado. Ya que estamos aprendiendo estas cosas nuevas, hay que dejar el pasado atrás, al menos de forma general, pueden haber casos, pero que sean la excepción.

Para aquellos que no estén familiarizados con unicode, decirles que Delphi XE (y algunas versiones anteriores) ya lo implementa, y entre las ventajas más impactantes es que pueden definir variables como "año", por lo que ya no hay que definir cosas como "anno".

Con respecto a la base de datos, podemos guardar datos como la palabra "Año", y si lo ve un alemán o un chino, se les mostrará la palabra "Año", y no un conjunto de símbolos raros.

Un paso previo es definir un alias a nuestra base de datos, una interesante opción de Firebird.
Para ello buscamos el archivo aliases.conf en la carpeta de firebird.
En mi caso, que uso Windows 7 x64 y Firebird x64 esa carpeta es: C:\Program Files\Firebird\Firebird_2_5

Mostrará un contenido como el siguiente, y añadimos al final nuestro alias.
#
# List of known database aliases
# ------------------------------
#
# Examples:
#
# dummy = c:\data\dummy.fdb
#
AliasDemo = "C:\Demo\DEMO.FDB"

Eso nos permitirá usar el alias en lugar de la dirección completa de la base de datos lo que nos permite mejorar tanto en comodidad como en seguridad, ya que no expondremos la ruta de nuestra base de datos.

Ahora registraremos nuestra base de datos en Delphi, e incluso podrémos crear desde Delphi las tablas, al menos de forma básica.

Está claro que para generar una base de datos compleja hay que usar algún programa especializado como el que ya comenté (SQL Manager Lite 2008)

Vamos a la pestaña DataExplorer, seleccionamos Firebird, pulsamos el botón derecho y elegimos "Add New Connection"

Ahora nos pregunta el nombre de la nueva conexión (no de la base de datos): escribimos ConexionDemo

Luego tenemos que cambiar los parámetros de esa conexión para indicarle que base de datos usamos.
Para ello pulsamos el botón derecho del ratón sobre nuestra conexión "Conexión Demo" y elegimos "Modify Connection"

Y como hemos definido un alias, lo que ponemos es el nombre del alias: AliasDemo

Importante: el alias es tal cual lo hemos definido en aliases.conf, es decir, una sóla palabra, sin ningún tipo de ruta de acceso ni de extensión., en nuestro caso ponemos AliasDemo.

Si no hubiéramos definido un alias, tenemos que poner el nombre completo, con ruta y extensión, de la base de datos del tipo: C:\Demo\DEMO.FDB

Ahora podemos crear una tabla directamente desde Delphi. Para ello, entramos en nuestra conexión "Conexión Demo" y sobre Tables, pulsamos el botón derecho del ratón y elegimos "New Table"

Ahora podemos definir los distintos campos de nuestra tabla que en nuestro caso serán el código y el nombre de los clientes
Una vez definidos pulsamos el botón derecho sobre esta rejilla y elegimos "Save Table".

En nuestro caso llamaremos a nuestra tabla Clientes y pulsamos el botón OK

Ahora en el Data Explorer, si desplegamos "Tables" podemos ver que ya está disponible nuestra nueva tabla Clientes.

Bastará con hacer doble clic sobre nuestra tabla "Clientes" para que nos salga una rejilla de datos que nos permitirá introducir datos directamente en nuestra tabla.
Una vez que hayamos terminado recordad pulsar el botón derecho del ratón sobre la rejilla y pulsar Update para que los cambios se graben en la base de datos, de lo contrario se perderán.

Y ya tenemos una base de datos, con una tabla y datos en ella.

Personalizar Rejilla de Datos - Custom Data Grid

2011-09-17T12:48:00.000+01:00

Esta procedimiento nos permite evitar que cada vez que pongamos una rejilla en un Form, tengamos que ir configurándola a nuestro gusto.

Pon esta función al iniciar un Form, normalmente en el evento OnCreate.

A modo de ejemplo, sólo he puesto el ancho de cada columna que se adapte a lo definido en el DataSet y la fuente al título de la rejilla pero podemos ir incluyendo todas las propiedades que queramos.

Tengamos en cuenta que muchos de los valores ya los coge la rejilla del DataSet, aquí sólo debemos poner los que no queramos que sean los estándar sino personalizados a nuestro gusto.

procedure InicializarRejilla (Rejilla:TDBGrid);
var i:integer;
begin
  for i := 0 to Rejilla.Columns.Count - 1 do
  begin
Rejilla.Columns[i].Width :=  Rejilla.DataSource.DataSet.FieldByName(Rejilla.Columns[i].FieldName).DisplayWidth;
  end;
Rejilla.TitleFont.Style := [FsBold];
end;

Nombre de archivo único - Unique file name

2011-09-17T12:36:00.000+01:00

Esta función nos devuelve un nombre de archivo único, muy útil cuando trabajamos con archivos temporales de cualquier tipo.
Podemos enviarle en Prefijo la cadena por la que queremos que comience el nombre.
Se usa la carpeta temporal de Windows, algo que podemos modificar si lo queremos crearlo en otra carpeta.

function NombreFicheroUnico (Prefijo:String):String;
var NewTempName, PathName : array [0..MAX_PATH] of char;
begin
    if (Length (Prefijo) = 0) then
        Prefijo := 'Tmp';
    GetTempPath (MAX_PATH, @PathName); // busca el directorio temporal de Windows
    GetTempFileName (PathName, PChar (Prefijo),0, @NewTempName);//Devuelve el nombre de fichero único
    result := NewTempName;
end;

Ejemplo: Aplicación de 3 capas multihilo con DBX4 y Delphi XE - multi-threaded application with Delphi XE and DataSnap DBX4

2011-09-13T19:15:00.000+01:00

Haremos un ejemplo de aplicación cliente servidor muy sencilla y lo explicaré lo más detallada posible.

APLICACIÓN SERVIDOR

Paso 1 Servidor
Abrimos Delphi y vamos a File - New - Other .

Paso 2 Servidor
Ahora vamoa a New Item elegir "Delphi Projects" - "DataSnap Server" y hacer clic "DataSnap Server" y "OK"

Paso 5: Servidor
Número de Puerto
Nos dejará elegir el número de puerto que usará nuestra aplicación.
Nos permitirá chequear si el puerto está en uso e incluso buscar uno libre.

Function TServerMethods2.HoraEnServidor: TDateTime;
begin
result := now;
end;

En esta unidad en donde podríamos, por ejmplo, poner los TSQLQuery con sus TDAtaSetProvider para suministrar datos de nuestra base de datos a los clientes.

Ahora abrimos la unit1 y le ponemos un TButton con el caption "iniciar"

Añadimos al uses la unidad: ServerContainerUnit1;

Y en el evento "on click" del TButton ponemos:

procedure TForm1.Button1Click(Sender: TObject);
begin if ServerContainer1.DSServer1.started then
begin
ServerContainer1.DSServer1.Stop;
Button1.Caption := 'Iniciar';
end
else
begin
ServerContainer1.DSServer1.Start;
Button1.Caption := 'Parar';
end;
end;

APLICACIÓN CLIENTE

Sobre el proyecto pulsamos el botón derecho del ratón y elegimos "Add New Project"

Hacemos clic sobre "Delphi Projects" y seleccionamos "VCL Form Application" y "OK"

Nos pedirá el tipo de servidor: Local o Remoto. La diferencia es que en el remoto pide nombre o IP del host y en el local no nos lo pide ya que pone "localhost"

Ahora nos pide el tipo de servidor: en nuestro caso será sólo con DataSnap stand alone server

Ahora nos pregunta que tipo de protocolo usaremos: en nuestro caso TCP/IP

Filtros de comunicaciones en DataSnap -Filters communications DataSnap

2011-09-08T20:06:00.001+01:00

En nuestras aplicaciones Cliente-Servidor y gracias al DataSnap 4 (DBX4) podemos realizar operaciones con los datos transmitidos entre ellas de una forma muy sencilla.

El ejemplo siguiente se corresponde con la compresión de los datos transmitidos para reducir el ancho de banda necesario para nuestras aplicaciones. También se pueden poner cifrados, algo que veremos más adelante.

Paso 1: Aplicación Servidor

En la unidad ServerContainerUnit debemos tener el componente DsServer.

Entonces añadimos, si es que no lo tenemos ya, el componente DSTCPServerTransport.

Ponemos su propiedad Server apuntando al DsServer

Una vez hecho eso, hacemos clic en su propiedad Filters.

Nos sale una ventana pequeña y hacemos clic en el botón "Add New"

Hacemos clic sobre el nuevo item que ha aparecido.

Sobre su propiedad FilterId escogemos ZLibCompression.

Paso 2. Aplicación Cliente

Abrimos a la unidad ClientModuleUnit.

Añadimos en la clausula uses DbxCompressionFilter

Y listo.

Convertir variable TEnum a String: Convert TEnum to String

2011-09-08T09:36:00.000+01:00

Si necesitamos usar el nombre de una variable TEnum en lugar de su valor, esta es una forma sencilla.

Voy a poner un ejemplo práctico para hacerlo algo más interesante:

Le pasaremos un campo de nuestra base de datos y nos devolverá la cadena de su propiedad DataType.

Para cualquier otra utilidad, basta con cambiar en la línea GetEnumName el

TFieldType por nuestra TEnum y

Campo.DataType por el valor que queremos comprobar.

Paso 1:

En nuestro form hay que incluir en el uses TypInfo

Paso 2:

function Enum2Str (Campo:TField): String;

begin

result := GetEnumName(TypeInfo(TFieldType),integer(Campo.DataType));

end;

Connection close gracefully

2011-09-07T20:36:00.000+01:00

Mensaje "connection close gracefully"

Este mensaje suele darse porque ha habido cambios en la aplicación servidor y en la aplicación cliente tiene la conexión abierta (TSQLConnection).

Para solucionarlo vamos al componente TSQLConnection de la aplicación cliente y ponemos la propiedad Active = False, normalmente puesta en el ClientModuleUnit.

A continuación volvemos a dejarla como estaba: Active = TRUE.