Mar 08

Pausar un programa con Delay y Sleep

Delay es un procedimiento de Free Pascal disponible en la unidad Crt que permite pausar el programa en x milisegundos.

Es sumamente útil cuando queremos mostrar un mensaje al usuario y que lo lea antes de hacer click casi por acto reflejo sin leer.

Para utilizarla simplemente escribimos

Delay (5000); //Pausa de 5 segundos

El parámetro que recibe el procedimiento es del tipo Word, por ende los valores deben estar dentro del rango 0 .. 65535. Esto nos da aproximadamente un minuto, ya que el tiempo es aproximado. Si se necesita más tiempo, no es necesario hacer varias llamadas a Delay dentro de un loop, sino que contamos con un procedimiento similar llamado Sleep que recibe como parámetro por valor del tipo Cardinal que es a su vez del tipo LongWord cuyo rango es 0 .. 4.294.967.295 lo cual es suficiente como para poner en coma el programa por casi 50 días.

Sleep (4294967000); // lo duerme por 50 días

Sin olvidarse de agregar Crt en uses para el caso de utilizar Delay o sysutils en caso de hacer uso de Sleep.

Documentación oficial de Delay.

Documentación oficial de Sleep.

 

Mar 07

Volver a cero el rowid de SQLite

Como reiniciar o “resetear” el rowid de una tabla en SQLite? Muchas veces definimos el famoso campo ID como integer, primary key, autoincrement, unique para que SQLite se encargue de él y lo hace, guardando el valor del último registro y cada vez que agregamos uno toma esa valor y lo incrementa en uno. Es por eso que si tenemos 10 registros con ID del 1 al 10 y borramos 5 y luego insertamos uno, el valor de este último será 11 y no 6. Si tememos una tabla con 500 filas y las borramos todas, el próximo registro, el ID será 501, si lo que buscamos es que sea 1 y no 501, hay una solución, luego de borrar toda la tabla ejecutamos el siguiente comando:

DELETE FROM SQLITE_SEQUENCE WHERE name='tutabla';

Ejemplo: borrar la tabla cuentas

DELETE FROM cuentas; DELETE FROM SQLITE_SEQUENCE WHERE name='cuentas';

Si devuelve el siguiente error: No such table ‘SQLITE_SEQUENCE’ se debe a que en el schema no está definido, sqlite_sequence se crea al definir una columna como integer, primary key, autoincremental, unique.

Es muy útil para tablas que usamos como temporales, no del tipo temporal que es distinto.

Otro ejemplo con código Free Pascal:

dmrc.ZQtemp.SQL.Text:='DELETE FROM tasiento; DELETE FROM SQLITE_SEQUENCE WHERE name=''tasiento'';';

 

Mar 07

Lazarus problema con acentos: solución.

A veces puede pasar que de un día para el otro y sin recordar haber hecho ningún cambio en nuestro IDE ni en el sistema operativo, Lazarus no acentúa, dicho de otra manera, se come los acentos o los duplica en el inspector de objetos. Y el resto de los programas que tenemos instalados no reproducen este error, es solo Lazarus. Nada grave, se puede convivir con ello y seguir programando sin ningún problema, por ejemplo, escribiendo el caracter acentuado en un editor de texto plano como Gedit y copiándolo y pegándolo en el editor de código fuente del RAD Lazarus. Nada cómodo pero sirve mientras buscamos “algo” que nos devuelva los acentos.

La solución que describo está comprobada exitosamente en Lazarus 1.6 FPC 3.0.0 sobre Linux Mint 17.2 x64 MATE Gtk-2.

Hay que hacer un script, con un editor de texto plano:

#!/bin/sh
export GTK_IM_MODULE=gtk-im-context-simple
export QT_IM_MODULE=simple
export XMODIFIERS=@im=none
startlazarus %f

Lo guardamos donde nos resulte cómodo con la extensión .sh y lo marcamos como ejecutable.
Y de ahora en más, lanzaremos Lazarus desde ese script. Este método está documentado en la wiki de Free Pascal.

Pantallazo

 

Mar 07

Crear tablas en SQLite con código Free Pascal

Como casi todo en programación, hay varias formas de hacer una misma tarea y ésta no es la excepción. Crearemos una base de datos y una tabla. También le agregaremos un registro a la tabla, todo con código Free Pascal desde Lazarus y utilizando un solo componente de Zeos Lib que no facilita las tareas con las bases de datos.

Ya he escrito que para crear una base de datos en SQLite solo hay que establecer la conexión, si la base de datos no existe, entonces SQLite la crea.
Solo necesitamos un TZConnection que lo soltaremos en el Form o en el Data Module.

Nota: al ZConnection1 en la propiedad protocol desde el inspector de objetos le seleccionamos sqlite3.

Este ejemplo consiste en una función que crea una base de datos, una tabla y un registro en la misma. Si todo salió bien se devuelve True, caso contrario, False.

function CrearEmpresas: Boolean;
var
  ret:Boolean;
begin
  ret:=True;
  if not FileExists('/home/programa1/empresas.db') then
  begin
    if ZConnection1.Connected then ZConnection1.Disconnect;
    try
      ZConnection1.Database:='/home/programa1/empresas.db';
      ZConnection1.Connect;
      ZConnection1.ExecuteDirect('CREATE TABLE IF NOT EXISTS empre ( '+
      'idempre INTEGER      PRIMARY KEY AUTOINCREMENT UNIQUE NOT NULL, '+
      'nombre  VARCHAR (40) NOT NULL, '+
      'cuit    VARCHAR (13) NOT NULL, '+
      'db      VARCHAR (40) NOT NULL, '+
      'dir     VARCHAR (80) NOT NULL );');
      ZConnection1.ExecuteDirect('INSERT INTO empre VALUES '+
      '(1,''DEMO EMPRESA S.A.'',''20-12345678-9'',''demodb.db'','+''''+CurrentDirectory+''');');
      ZConnection1.Disconnect;
    Except
      ret:=False;
    end;
    ZConnection1.Disconnect;
  end;
  CrearEmpresas:=ret;
end;  

Para evitar errores, primero verificamos que el archivo no exista y luego también chequeamos que ZConnection1 no esté conectado, pues si lo está no nos sirve, dado que para estar conectado lo está a una base de datos, y necesitamos crear la base de datos lo cual sucede al momento de efectuar la conexión. Por eso, si Connected devuelve True, lo desconectamos. Lo que sigue lo “envolvemos” en un try / Except y si salta algún error la función retornará False.

Ya asegurándonos de que ZConnection1 está desconectado, le establecemos la base de datos con path completo aunque sin path creará la DB en el directorio de ejecución, por lo tanto puede obviarse el path y poner ‘empresas.db’ por ejemplo. Conectamos y en ese momento es cuando la DB es creada. Acto seguido, valiéndonos del método ExecuteDirect incluiremos el mismo código que escribiríamos en una terminal o consola para SQLite con la diferencia de que necesitamos el uso de comillas dobles en la inserción de datos. Con el primer ExecuteDirect creamos la tabla empresas.db si no existe, algo que sobra porque acabamos de crear la DB. Con el segundo, agregamos un registro, ahora llamado fila, lo cual es correcto pero no me gusta. Y ahí debemos utilizar las comillas dobles, pulsando dos veces la comilla simple, no utilizar nunca la doble. El 1 al tratase de un entero, no necesita comillas, es un valor numérico, el resto de los campo (ahora columnas) al ser de texto (VARCHAR) si necesita estar entre comillas simples, pero al estar ya dentro de un texto entre comillas, para indicarle al compilador que la comilla no finaliza el texto, en lugar de una comilla simple escribimos dos comillas simples, el dato, y nuevamente dos comillas simples.

Ahora pasemos a explicar esto:

‘ ‘demodb.db’ ‘,  ‘+ ‘ ‘ ‘ ‘ + CurrentDirectory + ‘ ‘ ‘ ) ; ‘ ) ;

corto la cadena de caracteres luego de la coma, la finalizo con la comilla simple y le concateno el directorio actual:

‘ ‘ ‘ ‘  la primer comilla inicia el texto y la última lo cierra, en medio dos comillas imprimen una comilla en la cadena.
+ para agregar el string que me devuelve CurrentDirectory, nuevamente + ‘ ‘ ‘  tres comillas, la primera para iniciar nuevamente un texto, la segunda y tercera para imprimir una comilla, luego ) ; ‘ esa última comilla cierra.

Lo que sigue es un Disconnect que podría obviarse, pero prefiero que sobre y no que falte.

 

Mar 07

Unidad sin formulario en Lazarus

Es algo tan simple que no figura en los resultados de búsqueda de los pocos buscadores de Internet que hay en la actualidad a nivel global.

Desde la IDE Lazarus en el menú Archivo, Nueva unidad.

Pantallazo-IDE de Lazarus v1.6

Y nos aparecerá algo así:

unit Unit1;

{$mode objfpc}{$H+}

interface

uses
    Classes, SysUtils;

implementation

end.      

En definitiva lo único que falta es el Form y el resto es igual, como no podía ser de otra manera.

Luego de uses declaramos las funciones y procedimientos y debajo de implementation, las escribimos.

Ideal para tener todas las funciones de, por ejemplo, validación, en una unidad a la cual luego podremos acceder desde otras unidades. Otra utilidad práctica es para declarar variables globales.

 

Mar 02

Crear, leer y guardar un archivo de texto plano.

Caso: crear un archivo de texto donde se guarde el directorio o carpeta seleccionada por el usuario. Consultar dicho archivo. El método funciona tanto en GNU/Linux como en Windows.

Crear y guardar:

procedure TForm1.btnSeleccionarClick(Sender: TObject);
var
  f:TFileStream;
  s:String;
begin
  if SelectDirectoryDialog1.Execute then
  begin
    if SelectDirectoryDialog1.FileName<>'' then
      EmpresasDBDir:=SelectDirectoryDialog1.FileName;
  end
  else
  begin
    ShowMessage('No se seleccionó ningún directorio. Se utilizará el actual: '+GetCurrentDir);
    EmpresasDBDir:=GetCurrentDir; 
  end;
  f:=TFileStream.Create(GetCurrentDir+PathDelim+'empredir.txt',fmCreate);
  s:=EmpresasDBDir;
  f.Write(s[1],Length(s));
  f.Free;
end;    

Este evento es lanzado cuando el usuario presionar el botón seleccionar directorio. Las variables utilizadas son:

f del tipo TFileStream, s del tipo string, ambas locales;

EmpresasDBDir del tipo string, global, definida en otra unidad del proyecto.

Además se utiliza el componente SelectDirectoryDialog disponible en la paleta Dialogs de Lazarus.

Si el usuario no seleccionó ningún directorio, es decir, se escapó haciendo click en Cancelar o cerró el cuadro de diálogo, entonces, en lugar de preguntarle para qué presionó el botón si no seleccionó nada, se le informa amablemente que se utilizará el directorio actual, se le muestra el mismo mediante GetCurrenteDir y utilizando la misma función, se asigna el directorio actual a la variable global EmpresasDBDir.

Luego creamos el objeto de la clase TFileStream y le pasamos dos parámetros, el primero de ellos, el nombre del archivo y el segundo la forma mediante la cual accedemos al archivo, en este caso fmCreate que significa que creamos un nuevo archivo, entendiendo que si el archivo ya existe, lo sobrescribe. Respecto del primer parámetro, es un string, el cual formamos con el directorio actual + el delimitador + el nombre del archivo, cuya extensión puede ser otra que no sea .txt. El uso de PathDelim es lo que permite que funcione tanto en Linux como en Windows y seguramente también en MacOS que al igual que GNU/Linux está basado en UNIX, ya que el separador o delimitador entre carpeta y archivo será / o \ según el sistema operativo.

La asignación del contenido de la variable EmpresasDBDir a la variable s no es necesario, se podría prescindir de la misma y utilizar directamente EmpresasDBDir, eso queda a gusto del programador teniendo en cuenta la legibilidad del código.

f.Write(s[1], Length(s)) se guardan desde el primero s[1] al último Length(s) caracter de la cadena de caracteres s y se finaliza liberando el objeto.

Si quisiéramos que el archivo conste de varias lineas, habría que agregar #13#10 a la variable s

s:=EmpresasDBDir+#13#10;

Pero para este caso luego al leer el archivo e intentar conectar una base de datos con ese path, nos dará error, porque el Enter (#13#10) no se ve pero está ahí.

Leer el archivo:

procedure TForm1.LeoDirEmpreDB;
var
  f:TFileStream;
  s:String;
begin
  f:=TFileStream.Create(GetCurrentDir+PathDelim+'empredir.txt', fmOpenRead );
  SetLength(s,f.Size);
  f.Read(s[1],F.Size);
  EmpresasDBDir:=s;
  f.Free;
end;     

Para leer el archivo, en este caso no interviene el usuario de manera directa, lo realizo mediante un procedimiento y utlizando 2 variables locales f y s y la misma variable global EmpresasDBDir.

El método es parecido al de escritura, al crear el objeto, el primer parámetro es igual y el segundo no, con fmOpenRead, como su nombre lo indica, establecemos que solamente leeremos el archivo, en otras palabras: modo lectura. Paso siguiente, se debe establece el tamaño de s mediante SetLength le asignamos la misma cantidad de caracteres que contiene el archivo, si no hacemos, no funciona. Luego se realiza la lectura con el método Read del primer s[1] al último f.Size caracter. Lo leído lo asigno a la variable global y luego libero el objeto.

Se pueden hacer más cosas mediante el uso de TFileStream, como agregar datos a un fichero existente. También hay otros métodos para la lectura y escritura de archivos. Para más información recomiendo leer los siguiente enlaces:

Delphi al límite (en el cual me basé para este artículo).

FreePascal.org (Documentación oficial).

CuPas (Otro método, Pascal sin objetos).

 

Feb 20

Muy breve tutorial para empezar con Lazarus

Es este un sencillo ejemplo de primer programa para los recién llegados a Lazarus y a la programación con objetos.

Pantallazo

Iniciamos Lazarus, Archivo–> Nuevo–>Aplicación. Nos mostrará un formulario con su correspondiente unit. Antes de hacer nada seleccionamos Guardar todo, el 5to. icono, seleccionamos la carpeta donde se guardará la aplicación, y guardamos, son 2 la ventanas de diálogo de guardar que aparecerán, dejamos los nombres por defecto ya que es una práctica y guardamos.

Pantallazo-Crear un proyecto nuevo

Pantallazo

Cuando compilemos con éxito el programa, tendremos los siguientes archivos:

  • project1: es el ejecutable
  • project1.lpi: contiene información del proyecto, se recomienda no editar nunca este fichero,
  • project1.ico: como su extensión lo sugiere, es el icono.
  • project1.lps: guarda la configuración del proyecto y tampoco debería editarse nunca.
  • project1.lpr: Es el programa principal, se inicializa, se crea el formulario principal y se lanza el programa. Este archivo sí se puede editar (modificar), de hecho en la práctica se modifica habitualmente, aunque no mucho. Para comenzar, de momento, con algún ejercicio sencillo, no habrá que tocarlo.
  • project1.res: es una archivo binario de los recursos del programa.
  • unit1.pas: es el código fuente de la aplicación que estamos escribiendo.
  • unit1.lfm: sería como el código del formulario, o más bien sus propiedades. Salvo contadas excepciones, no hay que modificar nunca este archivo.

En los casos donde cito “no hay que modificar nunca este archivo” es porque lo hace Lazarus “para Lazarus”, se crear y actualizan automáticamente.

Todos los objetos tienen una propiedad “name” y la mayoría tiene una propiedad “caption”, como el caso del formulario TForm que Lazarus crea por defecto cuando creamos una unidad o aplicación. Estas propiedades, además de poder ser editadas mediante código, muchas veces se accede a ellas desde el inspector de objetos. Vamos a cambiar esas propiedades de nuestro formulario, lo llamaremos frmA y el caption es el texto que mostrará el formulario, se podremos simplemente Formulario A.

Pantallazo-2

Pantallazo-1

Pantallazo-Formulario A

Ahora a iremos incorporando objetos a nuestro Form, desde la paleta Standar seleccionamos un TLabel (es el 5to. botón) y lo colocamos en el formulario. Un TLabel es una etiqueta, que básicamente muestra un texto.

Pantallazo-Formulario A-1

Al TLabel le cambiaremos la propiedad (también se le llama atributo) caption. Nótese que la etiqueta se llama Label1, si colocásemos otra etiqueta, Lazarus la llamaría Label2. En caption pondremos: Este texto cambiará cuando presione el botón. Esto lo haremos desde el inspector de objetos, seleccionando Label1.

Pantallazo-4

Para mayor comodidad para escribir el texto es aconsejable presionar sobre los 3 puntos (…) en la propiedad caption, esto nos abrirá una ventana para ingresar es texto que mostrará la etiqueta.

Pantallazo-label

Pantallazo-Diálogo Editor de Strings

De paso podemos alinear la etiqueta horizontalmente al centro de la ventana, haciendo click derecho sobre la misma y seleccionando la opción “Alinear”.

Pantallazo-Alineación

Bien, ahora lo ideal sería incluir un botón, desde la paleta Standar el 4to. icono que dice “OK” es un TButton, incorporamos uno al formulario y le damos las dimensiones que queramos valiéndonos del mouse,

Pantallazo-Formulario A-2

Por default, Lazarus le asigna el nombre al componente Button1 y también al caption. Cambiaremos solo el caption y le pondremos “Haga click aquí.” o “Pinche aquí” o lo que más les guste.

Cabe destacar dos cosas, en Free Pascal, los objetos por convención (según tengo entendido) llevan una T al comienzo, por eso verán que todo es TForm, TLabel, TButton, TEdit, etc… Lo otro es que Lazarus define la instanciación de del objeto (variable) quitando la T y agregando un número, Form1, Label1, Button1, etc.

Hasta ahora no hemos escrito una sola línea de código, pero llego la hora de hacerlo, debemos hacer que cuando el usuario haga click en el botón cambie el texto de Label1. Para esto, hay que definir el evento OnClick de Button1. Evento: es un procedimiento asociado a un objeto y para una acción determinada. Esto es una definición breve muy básica, siempre hay que leer (y mucho) la wiki de Lazarus y la de Free Pascal.

Para ello, haremos click en Button1 y en el inspector de objetos y luego click en la pestaña “Eventos”, allí buscaremos el evento OnClick y haremos click en la segunda columna para que nos aparezcan los 3 puntos y haremos click sobre los mismos.

Pantallazo-6

Lazarus nos habrá mandado al editor de código fuente donde ya ha definido el evento.

Pantallazo-Editor de Código Fuente

Lo que sigue ahora sí, habrá que escribirlo, con la ayuda de autocompletar que es fundamental para evitar errores, comenzamos a escribir “lab” y presionamos [CTRL] + Sapce para autocompletar.

Pantallazo-Completion

Cuando vemos la “var” (variable) Label1 del tipo TLabel le damos Enter, escribimos un punto “.” y nuevamente Control + Espacio y buscamos la propiedad Caption, podemos escribir “ca” para hallarla más rápido. Ahora nos resta asignarle el valor que tomará la propiedad caption, por ejemplo:

procedure TfrmA.Button1Click(Sender: TObject);
begin
  Label1.Caption:='Gracias por presionar el botón.';
end;       

Para ir viendo como funciona, vamos a compilar, presionando F9 o haciendo click en el icono play.
Pantallazo-7
Y nos tendría que aparecer algo así:
Pantallazo-8
Lo probamos, hacemos click y el texto debe cambiar. Luego pulsar el botón de Stop o [Crtl] +F2 para finalizar.

Pantallazo-Formulario A-3

A esta altura ya creamos un ejecutable escribiendo solo una linea de código. Si bien el RAD Lazarus reduce mucho la cantidad de código a escribir, es erróneo pensar que todo será soltar componentes y escribir poco, mientras se va avanzando, cada vez se escribe más y, a su vez, iremos viendo que en algunos casos es mejor y a veces indispensable, algunos objetos definirlos “a mano” lo que se llama “en tiempo de diseño”, porque todo lo que arrastramos al formulario, puede escribirse e insisto, a veces solo queda esa opción, por ejemplo si queremos que cuando el usuario presione un botón se cree otro botón, el primer botón lo podemos crear soltando un TButton en el TForm, pero el segundo TButton deberemos crearlo, definirlo, mostrarlo y posiblemente eliminarlo mediante código.

Por último, dotaremos al formulario con un botón que muestre una imagen y una leyenda de “Cerrar” y cuya acción será finalizar la aplicación, es decir, cerrarla. El componente para esto se llama TBitBtn y está disponible en la paleta “Additional”, tiene la misma imagen que el TButton.

Pantallazo-9

Un BitBtn es un botón al que se le puede añadir una imagen, también posee imágenes prediseñadas, se encuentran en la propiedad “Kind” que por defecto es “bkCustom” y de momento lo dejamos así para añadir nuestra propia imagen, una apropiada para simbolizar la acción de cerrar. Para esto debemos tener una imagen, preferentemente guardada en nuestro disco, con realizar una búsqueda en Internet de “free icons” encontraremos unas cuantas.

Pantallazo-Formulario A-4

Para cargar la imagen, vamos al inspector de objetos y en la propiedad “Glyph” hacemos click en “…”:

Pantallazo-10

(También en Caption escribimos Cerrar).

Pantallazo-Diálogo Cargar Imagen - BitBtn1.Glyph

Se abrirá una nueva ventana de diálogo donde haremos click en Cargar y seleccionamos la imagen.

Pantallazo-Diálogo Cargar Imagen - BitBtn1.Glyph-1

Y click en Aceptar. En este caso la imagen la obtuve de aquí (icons8.com).

Y con esto terminamos el diseño de nuestro formulario que debería ser algo similar a esto;

Pantallazo-Formulario A-5

Quizas te estés preguntando “entonces para que existe TButton si TBitBtn es mejor?” y la respuesta es simple: hubo una vez en la que no existía TBitBtn y muchos programas se hicieron con TButton y se debe preservar la compatibilidad; y es correcto, desde ya. De mi parte no veo otro motivo y utilizo siempre TBitBtn que se puede utilizar sin ninguna imagen también, con el beneficio de que si el día de mañana le queremos agregar una imagen no tengo más que agregarla si la necesidad de cambiar el componente.

Solo nos falta hacer que el BitBtn1 cierre la aplicación y para ello recurriremos nuevamente al evento OnClick, tal como hicimos con Button1, buscamos en el inspector de objetos el evento OnClick del BitBtn1 y presionamos sobre los 3 puntos.

Escribimos

Close;       

Y nuestro código fuente tendría que verse así:
Pantallazo-Editor de Código Fuente-1
Compilamos (F9) y probamos.
Pantallazo-Formulario A-6
Y hasta acá llegamos con este muy breve tutorial o guía de inicio. Para finalizar, algunas anotaciones que nunca están de más:

Este código es el mismo para cualquiera de los sistemas operativos de escritorio soportados por Free Pascal, es decir, tanto en GNU/Linux, Windows o Mac OS se compilar este proyecto y funciona. Para proyectos “en serio” el 99% del código es el mismo y en muchos casos el 100%, es una de las principales ventajas de Free Pascal, además de ser de código abierto y la gran documentación online constantemente actualizada.

En este caso he utilizado la versión 3.0.0 de Free Pascal y 1.6.0 de Lazarus sobre Linux Mint 17.2 x86_64 MATE.

Lamentablemente y a pesar de ser el segundo o tercer lenguaje más utilizado en el planeta, no es mucha la documentación en español. Y si vamos al tema libros, al día de hoy solo he conseguido uno solo de Lazarus: “Iniciar con Lazarus y Free Pascal” el cual me ha servido mucho, el problema que tiene es la pésima traducción al español, por lo tanto, lo recomiendo pero en inglés. De hecho, el autor (Menkaura) me ha respondido muy amablemente un par de consultas que le hice por e-mail. Ojo que hay otro libro que en el título menciona a Lazarus pero solo le dedica un capítulo.

Es ideal antes de empezar con Lazarus, practicar Pascal puro desde la consola, luego practicar la programación orientada a objetos también desde consola, antes de comenzar con la IDE Lazarus.

Hay un sitio que recomiendo mucho, en español, Conone3000.com donde encontrarás de todo, incluyendo video tutoriales de Lazarus muy bien explicados.

Y desde ya los foros, no solamente planteando dudas, sino también leyendo todos los debates se aprende mucho.

La mayoría de lo que encuentres sobre Delphi es aplicable a Lazarus con Free Pascal, siempre teniendo en cuenta que Delphi es solamente Windows.

Foros en español de Lazarus:

El oficial: forum.lazarus.freepascal.org aunque el 99% del foro es en inglés.

Delphi Access: delphiaccess.com 100% es español con varios subforos, entre ellos, Lazarus.

Club Delphi: clubdelphi.com primo hermano de Delphi Access, también 100% en español.

Información oficial de la wiki de Free Pascal sobre los componentes vistos en este tutorial:

// Fin

 

Feb 16

SQLite crear una base de datos con código

A diferencia de otras bases de dato SQL, SQLite carece del famoso CREATE DATABASE porque si la base de datos no existe, la crea automáticamente.

En tiempo de diseño solo debemos completar la propiedad Database de un componente Zconnection y activar la propiedad Connected, con eso ya se creo la base de datos.

ZConnection_Database

Con código sería así:

ZConnection1.Database:='prueba.db'; 
ZConnection1.Connected:=true; 

Aclaración: Zconnection es un componente de ZeosLib, un conjunto de componentes para manejar bases de datos.

Feb 16

Tutorial Lazarus en español (PDF)

Este es el mejor curso para Lazarus que he encontrado, actualizado en 2015, del Lic. Ricardo De Castro Aquino, una joyita para quienes se inician en Lazarus con Free Pascal y como material de consulta permanente. Son 78 páginas imperdibles, muy bien explicado todo, mucho material para practicar.

Pantallazo-Curso Lazarus FPC - Basico 1 - revision 2015.pdf — Curso VFP 8

Descargar “Manual de Lazarus” Curso-Lazarus-FPC-Basico-1-revision-2015.pdf – Descargado 1077 veces – 3 MB

 

Feb 15

Editor de Lazarus: Atajos de teclado

Perfectamente explicado en http://wiki.lazarus.freepascal.org/Lazarus_IDE_Tools/es#Tabla_resumen_de_los_atajos

Muy completo tutorial tanto de los shortcuts como del autocompletado. Siempre es mejor leerlo en la wiki, pues puede haber alguna actualización. Pero nunca está demás una copia en PDF por las dudas.

 

Descargar “Atajos de teclado y autocompletado” Atajos-de-teclado.pdf – Descargado 12 veces – 582 KB

 

Entradas más antiguas «

» Entradas más recientes