Archive for the ‘Base de datos’ Category

Motivos para seleccionar PostgreSQL en lugar de MySQL

febrero 14, 2017

MySQL es un RDBMS muy popular y como seres humanos tendemos a aplicar la política del menor esfuerzo, así que cuando se requiere desarrollar una aplicación en donde es necesario utilizar una base de datos, la mayoría piensa inmediatamente en MySQL.

Yo siempre he preferido PostgreSQL sobre MySQL, a continuación expongo algunos de los motivos

La configuración por defecto de PostgreSQL respeta todas las restricciones y validaciones que se indican en el diseño de la base de datos, MySQL no, uno debe configurar el servidor en modo “Strict SQL”, de lo contrario, se insertarán valores “ajustados”.

Por ejemplo, no importa si una tabla se creó con un campo numérico con una restricción de NOT NULL, la configuración por defecto de MySQL permitirá insertar registros en esa tabla aún cuando no se especifique un valor para ese campo, almacenando un cero como valor. Aún seleccionando el modo “Strict SQL”, MySQL no soporta check constraints.

El único de los nueve motores de almacenamiento de MySQL que soporta integridad referencial y transacciones es InnoDB (MyISAM no soporta integridad referencial ni transacciones), PostgreSQL sólo trae un motor de almacenamiento y soporta integridad referencial y transacciones.

PostgreSQL cumple con ACID (Atomicity, Consistency, Isolation, Durability) al 100%, MySQL no, el mismo manual de MySQL no indica “full ACID complaint” sólo dice “follows ACID”

PostgreSQL soporta más tipos de datos y estructuras que MySQL

El tamaño máximo por renglón en una tabla de PostgreSQL es de 1.6TB mientras que en MySQL es de 65,535 bytes

Algunas cosas que MySQL no soporta y PostgreSQL si:

  • Full Outer Joins

  • Window Functions

  • CTE (Common Table Expressions) para SQL recursivo

  • Table functions

  • JSON (JavaScript Object Notation)

Para extender el servidor, MySQL cuanta con un plugin para C/C++, PostgreSQL soporta C/C++, Java, .Net, Perl, Python, Ruby, Tcl, ODBC y otros más

PostgreSQL es mejor que MySQL en cuanto a consistencia de datos, estabilidad, mantenimiento y recuperación de datos.

Algunas lecturas recomendadas:

http://www.slideshare.net/anandology/ten-reasons-to-prefer-postgresql-to-mysql

https://www.compose.io/articles/what-postgresql-has-over-other-open-source-sql-databases/

Diseño de bases de datos relacionales con Software Libre

noviembre 9, 2015

Para hacer el diagrama Entidad-Relación de una base de datos relacional es recomendable contar con una aplicación que nos permita (además de hacer el diagrama) generar un script de sql que podamos ejecutar en nuestro RDBMS para crear la base de datos.

La herramienta que yo uso se llama Power Architect, utilizo la versión Community Edition que se distribuye bajo una licencia GPL3 y además de forma gratuita. Cuenta con versión para Windows, OS X y para GNU/Linux (esta versión en la página aparece como Unix/Generic, supongo que significa que también funciona en algún sistema operativo Unix como FreeBSD, etc.)

Una vez que hemos creado el diagrama Entidad-Relación, la aplicación nos permite generar un script que contenga las instrucciones SQL necesarias para crear la base de datos en el RDBMS que seleccionemos (soporta MySQL, PostgreSQL, entre otros).

Necesitamos tener instalada una JVM (Java Virtual Machine) para poder ejecutar la aplicación

Migrar base de datos Firebird de 32 bits a 64 bits

diciembre 10, 2013

Si tenemos una base de datos Firebird funcionando en un sistema de 32 bits y queremos utilizar esa base de datos en un sistema con la versión de Firebird de 64 bits simplemente copiando el archivo .fdb de un sistema a otro, eso no va a funcionar.

Al intentar accesar a la base de datos obtendremos un mensaje de error diciendo que el archivo .fdb seleccionado no es una base de datos válida.

Lo que demos hacer es un respaldo de la base de datos en el sistema de 32 bits con la opción -t (transportable)

gbak -b -v -t -user sysdba -password masterkey basededatos.fdb respaldo.fbk

Ya que tenemos nuestro respaldo, hacemos el restore en el sistema de 64 bits

gbak -r -v  -user sysdba -password masterkey respaldo.fbk basededatos.fdb

Ahora debemos de poder accesar a nuestra base de datos con nuestra versión de 64 bits de Firebird

Instalar Sinatra + PostgreSQL + Datamapper en Debian Squeeze

septiembre 28, 2011

Sinatra es un DSL para desarrollo web utilizando el lenguaje de programación Ruby. A diferencia de Rails, Sinatra NO obliga a seguir el patrón Modelo Vista Controlador (aunque es posible desarrollar aplicaciones web de ese tipo con Sinatra). He notado que la mayoría de las personas que desarrollan aplicaciones web con acceso a base de datos, utilizan MySQL o incluso SQLite, pero yo prefiero PostgreSQL y no hay razón por la que no se pueda utilizar con Sinatra, así que en este post voy a utilizar ambos junto con un ORM llamado Datamapper para crear los modelos y erb para crear las vistas.

Instalar Ruby

Debian Squeeze trae la versión 1.8.7 de Ruby y la versión 1.9.2, vamos a instalar la versión más reciente (note que el paquete debian se llama ruby1.9.1 pero trae la versión 1.9.2 de Ruby)

sudo apt-get install ruby1.9.1

Una vez instalado, creamos un enlace simbólico al que llamaremos simplemente ruby

cd /usr/bin
sudo ln -s ruby1.9.1 ruby

Instalar RubyGems

De la página http://rubygems.org/pages/download descargamos el archivo .zip o .tgz y lo descomprimimos. Si se descarga el archivo rubygems-1.8.10.tgz, al descomprimirlo se crea un directorio rubygems-1.8.10, hay que cambiarse a ese directorio y ejecutar

sudo ruby setup.rb

Ahora creamos un enlace simbólico al que llamaremos gem

cd /usr/bin
sudo ln -s gem1.9.1 gem

Instalar Sinatra

sudo gem install sinatra

Ya tenemos instalado Sinatra, para probarlo, haremos un programa en Ruby con el clásico hola mundo :). El archivo lo guardamos con el nombre holamundo.rb


# holamundo.rb
require 'sinatra'

get '/' do
'Hola Mundo!'
end

Ahora desde la terminal tecleamos

ruby holamundo.rb

Y aparece lo siguiente:

== Sinatra/1.2.6 has taken the stage on 4567 for development with backup from WEBrick
[2011-09-26 13:39:22] INFO  WEBrick 1.3.1
[2011-09-26 13:39:22] INFO  ruby 1.9.2 (2010-08-18) [i486-linux]
[2011-09-26 13:39:22] INFO  WEBrick::HTTPServer#start: pid=3076 port=4567

Abrimos un navegador web y nos vamos a

http://localhost:4567

y veremos el texto Hola Mundo!

Para parar la ejecución, vamos a la terminal y tecleamos Ctrl-C y aparece

== Sinatra has ended his set (crowd applauds)
[2011-09-26 13:40:50] INFO  going to shutdown …
[2011-09-26 13:40:50] INFO  WEBrick::HTTPServer#start done.

Si en lugar del servidor web WEBrick queremos utilizar Thin, debemos instalar los paquetes ruby1.9.1-dev y build-essential

sudo apt-get install ruby1.9.1-dev build-essential

y ahora si instalamos Thin

sudo gem install thin

Instalar PostgreSQL

sudo apt-get install postgresql postgresql-contrib libpq-dev

Debemos poner un password al usuario postgres

sudo passwd postgres

Nos cambiamos al usuario postgres y asignamos un password al usuario postgres dentro de PostgreSQL

su postgres
psql -c “ALTER USER postgres WITH PASSWORD ‘password_aqui'” -d template1

Aparece ALTER ROLE y nos muestra nuevamente el prompt

Todavia como el usuario postgres crear un nuevo usuario en PostgreSQL. Para crear el usuario en PostgreSQL vamos a indicar que sea superusuario (-s), que PostgreSQL nos pida indicar el password para dicho usuario (-P) y nos muestre en pantalla los mensajes que esto genere (-e de –echo)

En este caso el usuario que voy a crear se llamará sysdba y le pondré como password la palabra s3cret

createuser -P -s -e sysdba

Aparece lo siguiente:

Ingrese la contraseña para el nuevo rol:
Ingrésela nuevamente:
CREATE ROLE sysdba PASSWORD ‘md51767410185836193fcba975fe021e85b’ SUPERUSER CREATEDB CREATEROLE INHERIT LOGIN;

Salimos del usuario postgres con exit

Editamos el archivo /etc/postgresql/8.4/main/pg_hba.conf para indicar que el usuario que acabamos de crear puede accesar a la linea de comandos de PostgreSQL (psql)

sudo nano /etc/postgresql/8.4/main/pg_hba.conf

Agregamos la linea
local   all         sysdba                           md5

en la sección # Database administrative login by UNIX sockets

y queda algo parecido a esto

# Database administrative login by UNIX sockets
local   all         postgres                          ident
local   all         sysdba                            md5

Reiniciamos el servidor PostgreSQL

sudo /etc/init.d/postgresql restart

Aparece

Restarting PostgreSQL 8.4 database server: main.

Nos conectamos a la línea de comandos de PostgreSQL con el usuario que creamos (en este caso sysdba) y creamos una base de datos para pruebas

psql -U sysdba template1

Aparece:

psql (8.4.8)
Digite «help» para obtener ayuda.

template1=#

Tecleamos \l para ver la lista de las bases de datos que existen actualmente

template1=# \l
Listado de base de datos
Nombre   |  Dueño   | Codificación | Collation  |   Ctype    |      Privilegios
———–+———-+————–+————+————+———————–
postgres  | postgres | UTF8         | es_MX.utf8 | es_MX.utf8 |
template0 | postgres | UTF8         | es_MX.utf8 | es_MX.utf8 | =c/postgres
: postgres=CTc/postgres
template1 | postgres | UTF8         | es_MX.utf8 | es_MX.utf8 | =c/postgres
: postgres=CTc/postgres
(3 filas)

template1=#

Crearemos una nueva base de datos (en este caso se llamará development)

template1=# CREATE DATABASE development;
CREATE DATABASE
template1=#

Verificamos que se haya creado la base de datos

template1=# \l
Listado de base de datos
Nombre    |  Dueño   | Codificación | Collation  |   Ctype    |      Privilegios
————-+———-+————–+————+————+———————–
development | sysdba  | UTF8         | es_MX.utf8 | es_MX.utf8 |
postgres    | postgres | UTF8         | es_MX.utf8 | es_MX.utf8 |
template0   | postgres | UTF8         | es_MX.utf8 | es_MX.utf8 | =c/postgres
: postgres=CTc/postgres
template1   | postgres | UTF8         | es_MX.utf8 | es_MX.utf8 | =c/postgres
: postgres=CTc/postgres
(4 filas)

template1=#

Salimos de la terminal de PostgreSQL

template1=# \q

Instalar el gem para conectarse desde Ruby a PostgreSQL

sudo gem install pg

Para checar que está funcionando, entramos a la linea de comandos de ruby (desde la terminal tecleamos irb1.9.1) y tecleamos

require ‘pg’

Nos debe regresar true. Salimos con quit

$ irb1.9.1
irb(main):001:0> require ‘pg’
=> true
irb(main):002:0> quit

Instalar Datamapper

sudo gem install data_mapper

Instalar el adaptador que permite a Datamapper comunicarse con la base de datos (en este caso PostgreSQL)

sudo gem install dm-postgres-adapter

Ya tenemos instalado todo lo necesario para desarrollar aplicaciones web con acceso a base de datos utilizando Sinatra!. Para probarlo pongo a continuación un pequeño programa con las vistas y un archivo css.

NOTA:


Si están instalando una versión más nueva de PostgreSQL (como la 9.4) y/o una versión más nueva de las gemas de ruby (como rubygems-2.6.7), es posible que al instalar la gema dm-postgres-adapter les marque un error algo asi como “Failed to build gem native extension.” y más abajo indica que no encontró el archivo postgres.h. La solución es instalar el paquete postgresql-server-dev-9.4

sudo apt-get install postgresql-server-dev-9.4

Después de esto, intentar nuevamente la instalación de la gema dm-postgres-adapter y ya debe instalarse sin problemas


Programa principal

El programa contiene un modelo en Datamapper llamado Linea, este modelo crea la tabla lineas en la base de datos development que creamos después de que instalamos PostgreSQL La tabla contiene sólo 2 campos; el campo cve_linea que es la llave primaria y el campo linea.

El programa hace las funciones de creación, lectura, actualización, borrado y listado de registros en la tabla

Archivo sinatra_test.rb


require 'sinatra'
require 'data_mapper'

configure do
# Se conecta a la base de datos
DataMapper.setup(:default, 'postgres://localhost/development')
DataMapper.setup(:default, {
  :adapter  => 'postgres',
  :host     => 'localhost',
  :username => 'sysdba' ,
  :password => 's3cret',
  :database => 'development'})
end

# Modelos
class Linea
  include DataMapper::Resource
  property :cve_linea, String, :length => 4, :required => true, :key => true
  property :linea, String, :length => 30, :required => true
end

DataMapper.auto_upgrade!

def campo_vacio(campo)
    campo.empty?
end

# menú principal
get '/' do
  erb :index
end

# muestra error debido a que un campo requerido se sejó vacío
get '/campo_vacio' do
  erb :error_campovacio
end

# *******************************
# LINEA
# *******************************

# nueva linea
get '/linea' do
  erb :reg_linea
end

# muestra el listado de lineas
get '/listalineas' do
  @lineas = Linea.all :order => :cve_linea
  erb :lista_lineas
end

# guarda la información de la linea
post '/linea' do
  @linea = Linea.new(:cve_linea => params[:cve_linea].upcase, :linea => params[:linea].upcase)
  if !campo_vacio(params[:cve_linea]) and !campo_vacio(params[:linea])
     if @linea.save
        redirect "/linea/#{@linea.cve_linea}"
     else
         redirect '/linea'
     end
  else
      redirect '/campo_vacio'
  end
end

# muestra los detalles de la linea
get '/linea/:cve_linea' do
  @linea = Linea.get(params[:cve_linea])
  if @linea
     erb :cons_linea
  else
      redirect '/linea'
  end
end

# muestra la forma para editar la linea
get '/editlinea/:cve_linea' do
  @linea = Linea.get(params[:cve_linea])
  if @linea
     erb :edit_linea
  else
      redirect '/listalineas'
  end
end

# muestra la forma para borrar la linea
get '/borralinea/:cve_linea' do
  @linea = Linea.get(params[:cve_linea])
  if @linea
     erb :borra_linea
  else
      redirect '/listalineas'
  end
end

# edita la linea
put '/editlinea/:cve_linea' do
  @linea = Linea.get(params[:cve_linea])
  if @linea
     @linea.linea = params[:linea].upcase
     @linea.save
     redirect '/listalineas'
  end
end

# borra la linea
delete '/borralinea/:cve_linea' do
  @linea = Linea.get(params[:cve_linea])
  if @linea
     @linea.destroy
     redirect '/listalineas'
  end
end

En el directorio en donde guardamos el programa principal (sinatra_test.rb) creamos dos directorios, uno llamado public y otro llamado views.
Dentro del directorio public creamos otro directorio que llamaremos stylesheets. Dentro de este directorio stylesheets vamos a poner nuestro archivo css (que llamaremos style.css). Sólo contendrá el código que nos permita “mostrar” el texto en mayúsculas automáticamente en los campos de captura. el programa sinatra_test.rb es el que convierte a mayúsculas el texto antes de guardarlo en la tabla.

Desde luego, ustedes pueden agregar el código css necesario para embellecer a su gusto la presentación de la aplicación.

Archivo public/stylesheets/style.css

.campo_entrada
{
 text-transform: uppercase;
}

Ahora en el directorio views vamos a crear las vistas

Archivo views/layout.erb

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<title>Ejemplo Sinatra</title>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<meta name="description" content="Acceso a base de datos en PostgreSQL" />
<meta name="keywords" content="Sinatra, Ruby, Datamapper" />
<link href="/stylesheets/style.css" rel="stylesheet" type="text/css" />
</head>
<body>
<%= yield %>
</body>
</html>

Archivo views/error_campovacio.erb


<div>


La información no se guardó debido a que dejó un campo vacío, por favor verifique!


<a href="/">Menú Principal</a>

</div>

Archivo views/index.erb


<h1>Menú Principal</h1>




<a href="/linea">Registro de líneas</a>



<a href="/listalineas">Listado de líneas</a>

Archivo views/reg_linea.erb


<div>

<form action="/linea" method="post" accept-charset="utf-8">
      <label>Clave de línea </label><input type="text" name="cve_linea" id="cve_linea" class="campo_entrada" maxlength=4>
      
      <label>Línea </label><input type="text" name="linea" id="linea" class="campo_entrada" maxlength=30>
      
      <input type="submit" value="Guardar"/>
    </form>



<a href="/">Menú Principal</a>

</div>

Archivo views/cons_linea.erb


<div>
    <label>Clave de línea </label><%= @linea.cve_linea %>
    
    <label>Línea </label><%= @linea.linea %>


<a href="/linea">Registro de líneas</a>



<a href="/">Menú Principal</a>

</div>

Archivo views/edit_linea.erb


<div>

<form action="/editlinea/<%= @linea.cve_linea %>" method="post" accept-charset="utf-8">
       <input type="hidden" name="_method" value="put">
       <label>Clave de línea </label><%= @linea.cve_linea %>
       
       <label>Línea </label><input type="text" name="linea" id="linea" class="campo_entrada" maxlength=30 value="<%= @linea.linea %>">
       
       <input type="submit" value="Guardar"/>
    </form>



<a href="/listalineas">Listado de líneas</a>



<a href="/">Menú Principal</a>

</div>

Archivo views/borra_linea.erb


<div>


Se borrará la siguiente línea: 


<form action="/borralinea/<%= @linea.cve_linea %>" method="post" accept-charset="utf-8">
       <input type="hidden" name="_method" value="delete">
       <label>Clave de línea </label><%= @linea.cve_linea %>
       
       <label>Línea </label><%= @linea.linea %>
       
       <input type="submit" value="Borrar"/>
    </form>



<a href="/listalineas">Listado de líneas</a>



<a href="/">Menú Principal</a>

</div>

Archivo views/lista_lineas.erb



Líneas registradas: <%= @lineas.length %>


<table>

<tr>

<th>Clave de línea</th>


<th>Línea</th>


<th></th>


<th></th>

</tr>

<% @lineas.each do |linea| %>

<tr>

<td><%= linea.cve_linea %></td>


<td><%= linea.linea %></td>


<td><a href="/editlinea/<%= linea.cve_linea %>">[editar]</a></td>


<td><a href="/borralinea/<%= linea.cve_linea %>">[borrar]</a></td>

   </tr>

<% end %>
</table>



<a href="/">Menú Principal</a>

Agregar y borrar usuarios de Firebird desde C++ builder

febrero 23, 2009

Agregar usuario

En la pestaña InterBase Admin de C++ builder 6 existe el componente TIBSecurityService, este componente sirve para agregar o borrar usuarios de un servidor de base de datos Firebird, así como para mostrar o modificar su información.

Suponiendo que dejamos la contraseña por default del usuario sysdba de Firebird y tenemos en un formulario de C++ Builder 6 (llamado Form1) un componente TButton llamado Button1 y 4 componentes TEdit llamados e_usuario, e_nombre, e_apellido y e_clave respectivamente, podríamos agregar un componente TIBSecurityService llamado IBSecurityService1 y poner el siguiente código en el evento OnClick de Button1 para agregar un usuario al servidor Firebird con los datos que contengan los TEdit.

void __fastcall TForm1::Button1Click(TObject *Sender)
{
  IBSecurityService1->Params->Values["user_name"]="sysdba";
  IBSecurityService1->Params->Values["password"]="masterkey";

  IBSecurityService1->Active = true;
  try
     {
      IBSecurityService1->UserName = e_usuario->Text;
      IBSecurityService1->FirstName = e_nombre->Text;
      IBSecurityService1->LastName = e_apellido->Text;
      IBSecurityService1->Password = e_clave->Text;
      IBSecurityService1->AddUser();
     }
  __finally
           {
            IBSecurityService1->Active = false;
           }
}

Notese que para indicar el usuario y password con el que se conectará el componente TIBSecurityService se usó

IBSecurityService1->Params->Values[“user_name”]=”sysdba”;
IBSecurityService1->Params->Values[“password”]=”masterkey”;

y no:

IBSecurityService1->Params->Add(“user_name = sysdba”);
IBSecurityService1->Params->Add(“password = masterkey”);

Ya que marcaría un error como “SPB Constant Unknown

Con esto queda agregado el usuario, pero falta hacer los grants para darle permisos de consulta (grant select), inserción (grant insert), borrado (grant delete) y actualización (grant update) sobre las tablas de la base de datos deseada.

Otorgar grants al usuario

Para esto, crearemos un stored procedure (procedimiento almacenado) en la base de datos.

El stored procedure (que llamaremos sp_Grants) otorgará todos los grants a un usuario sobre una tabla determinada; recibirá como parámetros el usuario y el nombre de la tabla.


/* Este procedure otorga todos los permisos al usuario que recibe como parámetro
   sobre la tabla que recibe como parámetro */

set term !! ;
create procedure sp_Grants(s_tabla varchar(65), s_usuario varchar(8))
as
  begin
        execute statement 'grant all on ' || :s_tabla || ' to ' || :s_usuario;
  end !!
set term ; !!

Agregamos a nuestro formulario un componente TIBDatabase llamado IBDatabase1 y un componente TIBStoredProc llamado IBSP_grants. En la propiedad Database del TIBStoredProc ponemos IBDatabase1 y en la propiedad StoredProcName SP_GRANTS (que es el nombre del stored procedure que creamos en la base de datos).

Por último agregamos un componente TListBox al que llamaremos lb_tablas. Lo que haremos será conectarnos a la base de datos, obtener los nombres de todas las tablas y pasarlos al ListBox, después iremos recorriendo el ListBox para otorgar todos los grants sobre todas las tablas al usuario llamando a nuestro stored procedure.

Basta con agregar el siguiente código al final del código que pusimos anteriormente en el evento OnClick del TButton llamado Button1.

En el ejemplo nuestra base de datos se llama prueba.fdb y se encuentra en el directorio llamado prueba de la unidad c:

 // Asigna la ruta a la base de datos
 IBDatabase1->Params->Values["user_name"]="sysdba";
 IBDatabase1->Params->Values["password"]="masterkey";
 IBDatabase1->DatabaseName = "c:\\prueba\\prueba.fdb";

 // Hace la conexión a la base de datos
 IBDatabase1->Connected=true;

 // Pasa los nombres de las tablas de la base de datos al ListBox
 IBDatabase1->GetTableNames(lb_tablas->Items,False);

 // Se desconecta de la base de datos
 IBDatabase1->Connected=false;

 for (int i_x=0; i_x<lb_tablas->Items->Count; i_x++)
     {
      IBSP_grants->ParamByName("s_tabla")->AsString = Trim(lb_tablas->Items->Strings[i_x]);
      IBSP_grants->ParamByName("s_usuario")->AsString = e_usuario->Text;
      IBSP_grants->ExecProc();
      lb_tablas->ItemIndex++;
     }
 lb_tablas->Clear();

Si queremos que no se vea el ListBox sólo debemos poner false en su propiedad Visible

Borrar usuario

Agregamos un componente TButton al que llamaremos Button2 y en su evento OnClick pondremos el siguiente código


void __fastcall TForm1::Button2Click(TObject *Sender)
{
  IBSecurityService1->Params->Values["user_name"]="sysdba";
  IBSecurityService1->Params->Values["password"]="masterkey";

  IBSecurityService1->Active = true;
  try
     {
      IBSecurityService1->UserName = e_usuario->Text;     
      IBSecurityService1->DeleteUser();
     }
  __finally
           {
            IBSecurityService1->Active = false;
           }
}

Nota: En el post la macro de wordpress muestra finally, pero debe ser __finally

Instalar firebird 2.0 en Debian Etch

febrero 5, 2009

En Debian Etch se encuentra el paquete firebird2-super-server pero la versión de firebird que contiene corresponde a la rama 1.5.x y no a la 2.0.x.

Para instalar la versión de firebird correspondiente a la rama 2.0.x debemos instalar el paquete firebird2.0-super que se encuentra en el repositorio de backports http://packages.debian.org/etch-backports/firebird2.0-super

Nota: La instalación fue realizada en una PC con la versión de Debian Etch en inglés, por lo que los mensajes y pantallas que se muestran contienen los textos en inglés pero el proceso que se debe seguir en la versión en español es el mismo.

Lo primero que debemos hacer es agregar el repositorio de backports al archivo de fuentes /etc/apt/sources.list para lo cual insertamos las siguientes lineas:

deb http://www.backports.org/debian etch-backports main contrib non-free
deb-src http://www.backports.org/debian etch-backports main contrib non-free

Despues hacemos sudo apt-get update
Cuando termina, al final nos muestra un mensaje como el siguiente:

Reading package lists… Done
W: GPG error: http://www.backports.org etch-backports Release: The following signatures couldn’t be verified because the public key is not available: NO_PUBKEY EA8E8B2116BA136C

No hay problema, el error es porque no tenemos la clave para la autenticación del repositorio backports.
Lo solucionamos instalando el paquete debian-backports-keyring:

sudo apt-get install debian-backports-keyring

Aparece el siguiente mensaje:

Reading package lists… Done
Building dependency tree… Done
The following NEW packages will be installed:
debian-backports-keyring
0 upgraded, 1 newly installed, 0 to remove and 86 not upgraded.
Need to get 3310B of archives.
After unpacking 49.2kB of additional disk space will be used.
WARNING: The following packages cannot be authenticated!
debian-backports-keyring
Install these packages without verification [y/N]?

Decimos que si y la instalación continúa

Get:1 http://www.backports.org etch-backports/main debian-backports-keyring 2007.06.10 [3310B]
Fetched 3310B in 2s (1640B/s)
Selecting previously deselected package debian-backports-keyring.
(Reading database … 43431 files and directories currently installed.)
Unpacking debian-backports-keyring (from …/debian-backports-keyring_2007.06.10_all.deb) …
Setting up debian-backports-keyring (2007.06.10) …
OK

Ahora si procedemos a instalar firebird 2.0 en su arquitectura super server

sudo apt-get install firebird2.0-super

Al final muestra este mensaje

Setting up firebird2.0-super (2.0.3.12981.ds1-14~bpo40+1) …
Created default security.fdb
Firebird 2.0 server manager not running.
* Not starting Firebird 2.0 server manager
* Use `dpkg-reconfigure firebird2.0-super’ to enable.

Ejecutamos sudo dpkg-reconfigure firebird2.0-super y en la pantalla que aparece seleccionamos Yes
config_firebird_1
En la siguiente pantalla ponemos un password para el usuario SYSDBA

config_firebird_2
y después de dar OK la instalación termina indicandonos que el servidor ya esta funcionando.

Firebird 2.0 server manager not running.
Starting Firebird 2.0 server manager…done.
GSEC> GSEC> Firebird 2.0 server manager already running.

Para verificar que está corriendo el servidor ejecutamos

top -b -n1 | grep fb

Debe aparecer un proceso llamado fbguard y uno llamado fbserver

2353 firebird  20   0  3720 1492 1240 S  0.0  0.8   0:00.00 fbguard
2354 firebird  19   0 36272 4192 3060 S  0.0  2.2   0:00.05 fbserver

Creamos un directorio en donde pondremos la base de datos que será accesible desde los clientes remotos con Windows

sudo mkdir /database

Ponemos como propietario del directorio al usuario firebird

sudo chown firebird.firebird /database

Copiamos a este directorio la base de datos, en este caso se llama baseprueba.fdb.
Ya que tenemos la base de datos en ese directorio, ponemos como propietario al usuario firebird

cd /database
sudo chown firebird.firebird baseprueba.fdb

Ahora vamos al directorio /etc/firebird/2.0 y editamos el archivo aliases.conf para crear un alias para la base de datos indicando la ruta en que se encuentra:

Agregamos la siguiente linea al final del archivo aliases.conf
baseprueba.fdb = /database/baseprueba.fdb

Eso es todo, la ruta que deben usar las maquinas cliente en windows para accesar a la base de datos es la IP del servidor, seguido de dos puntos y el alias de la base de datos.

Por ejemplo 192.168.1.10:baseprueba.fdb

Para información de firebird en español se puede consultar el siguiente enlace http://www.firebird.com.mx