Recordatorio sobre libros de Informática gratis

2 comentarios

Desde el día jueves 24 de abril hasta el día viernes 25 de abril de 2014 la Editorial ENI permitirá la lectura a través de su sitio web de libros de Informática, son algo más de 180 títulos sobre temas variados, tanto para principiantes como para avanzados.

Para registrarte debes acceder a esta página:

http://www.ediciones-eni.com/librosgratis

donde te pedirán tu e-mail, al cual enviarán la contraseña que usarás para acceder a la lectura de los libros.

Aprovecha la oportunidad, siempre es bueno aprender más.

Artículos relacionados:

Libros gratis sobre Informática durante dos días

El índice del blog Firebird21

 

Nombres de tablas con guión bajo

Deja un comentario

Si quieres que el nombre de una tabla empiece con un guión bajo tendrás problemas porque el Firebird no admite al guión bajo como primer carácter del nombre de una tabla.

Sin embargo … hay una solución.

Y la solución es rodear al nombre de la tabla con comillas, así:

CREATE TABLE
   "_CON_GUION"
   (GUI_IDENTI INTEGER,
    GUI_NOMBRE VARCHAR(40));

Desde luego que para acceder a esa tabla siempre tendrás que usar las comillas, por ejemplo:

INSERT INTO "_CON_GUION"
           (GUI_IDENTI, GUI_NOMBRE)
    VALUES (1         , 'SILVIA BEATRIZ');

SELECT
   *
FROM
   "_CON_GUION"

Conclusión:

A veces podría ser útil que los nombres de algunas tablas empiecen con un guión bajo, el Firebird no nos permite eso, salvo que el nombre de la tabla esté rodeado por comillas.

Artículo relacionado:

El índice del blog Firebird21

 

Optimizando las subconsultas

2 comentarios

Las subconsultas son una herramienta muy útil que tenemos a nuestra disposición pero que en ocasiones pueden ser muy lentas. Consideremos este caso:

SELECT
   C.MVC_FECHAX,
   C.MVC_NRODOC,
   (SELECT SUM (D.MOV_CANTID * D.MOV_PRECIO) FROM MOVIMDET D WHERE D.MOV_IDECAB = C.MVC_IDENTI),
   (SELECT MAX (D.MOV_CANTID * D.MOV_PRECIO) FROM MOVIMDET D WHERE D.MOV_IDECAB = C.MVC_IDENTI),
   (SELECT MIN (D.MOV_CANTID * D.MOV_PRECIO) FROM MOVIMDET D WHERE D.MOV_IDECAB = C.MVC_IDENTI),
   (SELECT AVG (D.MOV_CANTID * D.MOV_PRECIO) FROM MOVIMDET D WHERE D.MOV_IDECAB = C.MVC_IDENTI)
FROM
   MOVIMCAB C

Aquí, tenemos una tabla cabecera de movimientos (MOVIMCAB) y una tabla de detalles de movimientos (MOVIMDET).

Y lo que nos interesa es hallar, para cada venta realizada, el total de esa venta (usamos la función SUM()), la línea con el mayor total (usamos la función MAX()), la línea con el menor total (usamos la función MIN()), y el promedio de las líneas (usamos la función AVG()).

Todo bien hasta aquí y el SELECT anterior cumple con su objetivo pero … hay un pero. Y ese pero es que escribimos 4 subconsultas. Y cada subconsulta es independiente a las otras y por lo tanto se emplea mucho tiempo en obtener los resultados deseados. Se los obtiene, sí, pero se demora mucho en obtenerlos (por supuesto que en el caso de tablas muy grandes, si las tablas son pequeñas no se notará la demora).

Entonces, ¿podemos optimizar este SELECT para que se ejecute más rápido?

Sí, podemos.

El truco es realizar una sola subconsulta, y en ella obtener todos los datos que nos interesan, como vemos a continuación:

 

SELECT
   C.MVC_FECHAX,
   C.MVC_NRODOC,
   CAST(LEFT     (TodoJunto, 10)            AS BIGINT),
   CAST(SUBSTRING(TodoJunto FROM 11 FOR 10) AS BIGINT),
   CAST(SUBSTRING(TodoJunto FROM 21 FOR 10) AS BIGINT),
   CAST(RIGHT    (TodoJunto, 10)            AS BIGINT)
FROM
   (SELECT
       MOVIMCAB.MVC_IDENTI,
       (SELECT
           LPAD(SUM(MOV_CANTID * MOV_PRECIO), 10) ||
           LPAD(MAX(MOV_CANTID * MOV_PRECIO), 10) ||
           LPAD(MIN(MOV_CANTID * MOV_PRECIO), 10) ||
           LPAD(AVG(MOV_CANTID * MOV_PRECIO), 10)
        FROM
           MOVIMDET
        WHERE
           MOV_IDECAB = MVC_IDENTI) AS TodoJunto
    FROM
       MOVIMCAB) AS DERIVADA
JOIN
   MOVIMCAB C
      ON C.MVC_IDENTI = DERIVADA.MVC_IDENTI

 Aquí, para cada fila de la tabla MOVIMDET se realiza una sola subconsulta y se concatenan las columnas para guardarlas con el alias TodoJunto.

Como puedes ver, esta consulta es más complicada de escribir que la original, pero la ventaja es que se obtienen los resultados mucho más rápidamente porque cada fila de la tabla MOVIMDET es recorrida una sola vez, no 4 veces como en la consulta original.

Conclusión:

Se pueden optimizar las subconsultas concatenando las columnas que nos interesan y luego «desconcatenarlas».

Esta técnica para optimizar las subconsultas es muy útil cuando las tablas son muy grandes (es decir: tienen millones de filas) porque se consigue obtener los resultados muy rápido. El motivo es que cada fila de la tabla de detalles se recorre una sola vez.

Si no usamos esta técnica, cada fila de la tabla de detalles sería recorrida 4 veces. Y recorrer las filas 4 veces evidentemente es mucho más lento que recorrerlas 1 sola vez.

Sin embargo, si las tablas son pequeñas y siempre lo serán, probablemente no valga la pena el esfuerzo de optimizar las subconsultas.

Así que queda a tu criterio si decides optimizarlas o no, pero al menos ya conoces una técnica para optimizarlas si lo deseas.

Artículos relacionados:

Tablas derivadas

Entendiendo subconsultas y tablas derivadas

El índice del blog Firebird21

 

Usando MEGA para guardar archivos en la nube

Deja un comentario

Desde hace un tiempo han surgido varios programas que te permiten guardar tus archivos en la nube, quizás el más famoso de todos ellos es Dropbox.

Ahora, tenemos otra opción: Mega.

Mega es el nuevo nombre de MegaUpload, un sitio web muy popular para guardar y descargar archivos grandes que fue clausurado por intervención del FBI y de la NSA yanquis.

Como te puedes imaginar, ambas agencias no está bien conceptuadas en la mente de la mayoría de los internautas. Ni en la de Mega, como descubrirás si instalas el programa.

¿Qué te ofrece Mega?

  • 50 Gb gratis, para guardar allí cualquier tipo de archivo. También puedes renombrarlos, moverlos o eliminarlos
  • Encriptación de alto nivel durante la transferencia, para evitar que el FBI, la NSA, o cualquier otra agencia curiosee en tus archivos
  • Poder crear todas las carpetas y subcarpetas que desees. También puedes renombrarlas, moverlas o eliminarlas
  • Elegir el idioma que más te guste, el castellano (español) entre ellos
  • Limitar el ancho de banda usado para las transferencias, para no interferir con las otras subidas o descargas que realices
  • Excluir archivos, o extensiones de archivos, para no subirlos a la nube
  • La posibilidad de obtener más espacio en la nube, aunque eso tendrás que pagarlo

¿Para qué puedes usar Mega?

  • Para subir a la nube cualquier archivo y así tener un backup actualizado del mismo. Podrías subir tus programas fuente, tus fotografías, tus planillas Excel, tus documentos Word, tus documentos PDF, tus canciones, y en general cualquier archivo que desees.
  • Si le ocurriera algún daño a tu disco duro o a tu pen-drive pues ningún problema con eso, tus archivos aún estarán a tu disposición porque estarán guardados también en la nube, desde donde los podrás descargar cuando lo desees.

¿Para qué NO deberías usar Mega?

Para guardar en la nube tu Base de Datos y permitir a los usuarios que se conecten a ella. Por supuesto que puedes guardar una copia de tu Base de Datos en la nube pero solamente como backup, los usuarios no deberían conectarse a ella o la corromperán gravemente.

¿Desde dónde se puede descargar el instalador de Mega?

https://mega.co.nz/MEGAsyncSetup.exe

Artículos relacionados:

¿Se puede usar DropBox con bases de datos?

El índice del blog Firebird21

El foro del blog Firebird21

Libros gratis sobre Informática durante dos días

5 comentarios

Ediciones ENI, una editorial especializada en libros de Informática, pondrá gratuitamente a disposición de los internautas durante los días 24 y 25 de abril de 2014, todo su catálogo de libros.

Son 180 títulos que tratan sobre temas muy variados: Sistemas Operativos, Programación, Ofimática, Seguridad, Diseño web, Administración de redes, etc. Hay tanto para principiantes como para avanzados.

Si estás interesado, recuerda que esos libros estarán a tu disposición durante los días jueves 24 de abril y viernes 25 de abril de 2014.

http://www.ediciones-eni.com/

Y para registrar tu e-mail y recibir una contraseña que te permitirá leer libros:

http://www.ediciones-eni.com/librosgratis

Artículo relacionado:

El índice del blog Firebird21

 

Crear una tabla e insertarle filas DENTRO de un stored procedure

Deja un comentario

Casi siempre lo recomendable es que todas las tablas las crees afuera de tus stored procedures porque de esa manera el Firebird puede detectar cualquier error que cometas antes de que la tabla sea creada, y eso te evitará problemas futuros.

Sin embargo, a veces puedes necesitar crear una tabla adentro de un stored procedure y también insertarle datos a esa tabla.

La técnica para conseguirlo es usar el comando EXECUTE STATEMENT con la opción WITH AUTONOMOUS TRANSACTION, como puedes ver en el siguiente ejemplo:

CREATE PROCEDURE CREAR_E_INSERTAR
AS
   DECLARE VARIABLE lcNombreTabla VARCHAR(31);
   DECLARE VARIABLE lcComando     VARCHAR(32000);
BEGIN

   lcNombreTabla = 'PRUEBA1';

   lcComando = 'CREATE TABLE ' || lcNombreTabla || ' (PRU_IDENTI INTEGER, PRU_NOMBRE VARCHAR(80))' ;

   EXECUTE STATEMENT :lcComando WITH AUTONOMOUS TRANSACTION;

   lcComando = 'INSERT INTO ' || lcNombreTabla || '(PRU_IDENTI, PRU_NOMBRE) VALUES (1, ''AMÉRICA'')';

   EXECUTE STATEMENT :lcComando WITH AUTONOMOUS TRANSACTION;

   lcComando = 'INSERT INTO ' || lcNombreTabla || '(PRU_IDENTI, PRU_NOMBRE) VALUES (2, ''ÁFRICA'')';

   EXECUTE STATEMENT :lcComando WITH AUTONOMOUS TRANSACTION;

   lcComando = 'INSERT INTO ' || lcNombreTabla || '(PRU_IDENTI, PRU_NOMBRE) VALUES (3, ''ASIA'')';

   EXECUTE STATEMENT :lcComando WITH AUTONOMOUS TRANSACTION;

   lcComando = 'INSERT INTO ' || lcNombreTabla || '(PRU_IDENTI, PRU_NOMBRE) VALUES (4, ''EUROPA'')';

   EXECUTE STATEMENT :lcComando WITH AUTONOMOUS TRANSACTION;

   lcComando = 'INSERT INTO ' || lcNombreTabla || '(PRU_IDENTI, PRU_NOMBRE) VALUES (5, ''OCEANÍA'')';

   EXECUTE STATEMENT :lcComando WITH AUTONOMOUS TRANSACTION;

END;

Aquí, se crea una tabla llamada PRUEBA1, la cual está compuesta por dos columnas: PRU_IDENTI y PRU_NOMBRE. Luego de crear la tabla se le insertan 5 filas. El resultado de ejecutar este stored procedure es el siguiente:

CREAR1

Captura 1. Si haces clic en la imagen la verás más grande

En la Captura 1 podemos ver que se ha creado la tabla llamada PRUEBA1, con las columnas que habíamos especificado.

CREAR2

Captura 2. Si haces clic en la imagen la verás más grande

Y en la Captura 2 vemos que también se le insertaron las filas que habíamos pedido que se inserten.

Comentarios:

Al utilizar WITH AUTONOMOUS TRANSACTION el efecto es ejecutar el comando COMMIT dentro de nuestro stored procedure. Por defecto el Firebird no nos permite escribir ni COMMIT ni ROLLBACK dentro de un stored procedure pero podemos engañarle y ejecutar un COMMIT cuando llamamos al comando EXECUTE STATEMENT con la opción WITH AUTONOMOUS TRANSACTION.

Hay que recordar, sin embargo, que utilizar EXECUTE STATEMENT … WITH AUTONOMOUS TRANSACTION tiene sus desventajas:

  1. El Firebird no verifica que el comando a ejecutar sea correcto antes de ejecutarlo. La verificación siempre se hace después y si hay algo mal escrito entonces solamente se descubrirá en tiempo de ejecución (quizás por un usuario malhumorado).
  2. Usar EXECUTE STATEMENT es lento porque el comando no está compilado, debe ser compilado en el momento de ser ejecutado

 Si luego de sopesar las ventajas y desventajas decides que necesitas un COMMIT dentro de un stored procedure entonces recuerda que lo conseguirás usando AUTONOMOUS TRANSACTION.

Artículos relacionados:

EXECUTE STATEMENT

Usando EXECUTE STATEMENT con argumentos

El índice del blog Firebird21

 

 

 

Un ejemplo del uso de funciones en Firebird

Deja un comentario

En este artículo ya habíamos visto que actualmente (versión 2.5.2) el Firebird no dispone de funciones nativamente pero que fácilmente podemos simular que sí las tiene.

Usando un stored procedure como una función

Ahora, veremos un ejemplo práctico de como usar una función.

Ejemplo. Obteniendo la parte gravada y el impuesto

El Gobierno cobra un impuesto por cada venta que se realiza en el país. El valor monetario de ese impuesto se calcula como un porcentaje sobre lo que se le cobra al cliente. Por lo tanto:

PrecioVenta = ImporteGravado + Impuesto     (1)

Como el Impuesto es siempre un porcentaje sobre el ImporteGravado entonces la fórmula es:

Impuesto = ImporteGravado * PorcentajeImpuesto / 100     (2)

Y reemplazando la fórmula del Impuesto en (1) obtenemos:

PrecioVenta = ImporteGravado + ImporteGravado * PorcentajeImpuesto / 100     (3)

Que también podemos escribir como:

PrecioVenta = ImporteGravado * (1 + PorcentajeImpuesto / 100)     (4)

En una tabla llamada FACTURAS tenemos guardado el PrecioVenta y también el PorcentajeImpuesto y lo que queremos hallar es:

  1. El ImporteGravado
  2. El Impuesto

 Para ello, escribimos el siguiente stored procedure seleccionable:

CREATE PROCEDURE DISCRIMINAR_VENTA(
   tnPrecioVenta NUMERIC(12, 2),
   tnPorcentaje  NUMERIC(5, 2))
RETURNS(
   ftnGravado  NUMERIC(12, 2),
   ftnImpuesto NUMERIC(12, 2))
AS
BEGIN

   -- tnPrecioVenta = ftnGravado * (1 + tnPorcentaje / 100)

   ftnGravado = tnPrecioVenta / (1 + tnPorcentaje / 100);

   ftnImpuesto = ftnGravado * tnPorcentaje / 100;

   SUSPEND;

END;

Al cual podemos llamar de esta forma:

SELECT
   F.FAC_MONTOX,
   D.ftnGravado,
   D.ftnImpuesto,
   D.ftnGravado + D.ftnImpuesto
FROM
   FACTURAS F
LEFT JOIN
   DISCRIMINAR_VENTA(F.FAC_MONTOX, F.FAC_PORIVA) D
      ON 1 = 1

Desde luego que F.FAC_MONTOX y D.ftnGravado + D.ftnImpuesto deben ser idénticos, se escribió a ambos solamente para comprobar lo evidente.

En este caso tenemos una tabla llamada FACTURAS, dentro de la cual tenemos una columna llamada FAC_MONTOX donde guardamos el precio de venta y una columna llamada FAC_PORIVA donde guardamos el porcentaje del impuesto.

Al llamar a la función DISCRIMINAR_VENTA obtenemos la parte gravada y el impuesto que corresponden a cada venta realizada.

Artículos relacionados:

Usando un stored procedure como una función

El índice del blog Firebird21

 

Usando un stored procedure como una función

Deja un comentario

En los lenguajes de programación existe un tipo de rutina al cual se le llama FUNCIÓN.

La característica de una FUNCIÓN es que puede recibir cero, uno, o varios parámetros de entrada y siempre devuelve exactamente un parámetro de salida.

Ese parámetro de salida devuelto por una FUNCIÓN puede ser asignado a una variable, utilizado en una fórmula, o comparado con otros valores.

Firebird actualmente no dispone de funciones, sí tiene stored procedures pero no tiene funciones. Éstas recién estarán disponibles cuando se libere la versión 3.0

Pero mientras tanto aunque no tenga funciones nosotros podemos simular que sí las tiene. Para ello utilizaremos un truco. La sintaxis para usar a un stored procedure como si fuera una función es la siguiente:

SELECT
   T.MiColumna1,
   F.MiValor
FROM
   MiTabla T
LEFT JOIN
   MiStoredProcedureSeleccionable(T.MiColumna1) F
      ON 1 = 1

Entendiendo al truco:

  1. El stored procedure debe ser seleccionable. O sea que debe tener el comando SUSPEND en él.
  2. Es preferible usar LEFT JOIN para que aún en el caso de que el stored procedure devuelva NULL se puedan obtener las columnas de la tabla principal
  3. La condición del LEFT JOIN debe ser siempre verdadera. Al poner 1 = 1 nos aseguramos que así sea, porque evidentemente 1 siempre será igual a 1.

Usando el valor devuelto por la función

El valor que nos devolvió nuestra función (en realidad nuestro stored procedure seleccionable, como ya sabes) a todos los efectos puede ser tratado como si fuera una columna más. O sea que lo podemos usar en una fórmula, con la cláusula WHERE, con la cláusula ORDER BY, etc.

Ejemplo 1:

SELECT
   T.MiColumna1,
   F.MiValor,
   T.MiColumna2 * F.MiValor
FROM
   MiTabla T
LEFT JOIN
   MiStoredProcedureSeleccionable(T.MiColumna1) F
      ON 1 = 1

En este ejemplo multiplicamos a F.MiValor (que es el valor que devolvió la función) por T.MiColumna2. O sea que usamos a F.MiValor en una fórmula

Ejemplo 2:

SELECT
   T.MiColumna1,
   F.MiValor
FROM
   MiTabla T
LEFT JOIN
   MiStoredProcedureSeleccionable(T.MiColumna1) F
      ON 1 = 1
WHERE
   F.MiValor = 125

En este caso usamos a F.MiValor en una condición de la cláusula WHERE

Ejemplo 3:

SELECT
   T.MiColumna1,
   F.MiValor
FROM
   MiTabla T
LEFT JOIN
   MiStoredProcedureSeleccionable(T.MiColumna1) F
      ON 1 = 1
ORDER BY
   F.MiValor

Ahora, ordenamos el conjunto resultado según el valor que tenga F.MiValor

Conclusión:

Aunque actualmente Firebird no dispone de funciones (las dispondrá cuando salga la versión 3.0) eso no es problema para nosotros porque podemos simularlas muy fácilmente. Para ello lo único que debemos hacer es crear un stored procedure seleccionable, hacer un LEFT JOIN a ese stored procedure seleccionable y asegurarnos que la condición siempre sea verdadera (al poner 1 = 1 nos aseguramos de que así sea).

Y además, este truco tiene una ventaja adicional: no es precioso que el stored procedure devuelva solamente un parámetro de salida, puede devolver varios, y los podemos usar a todos ellos si queremos. O sea que si MiStoredProcedureSeleccionable devuelve los parámetros de salida MiValor1, MiValor2, MiValor3, en nuestro SELECT podremos usar a MiValor1, MiValor2, y MiValor3, si así lo deseamos. ¡¡¡Excelente!!!

Artículos relacionados:

El índice del blog Firebird21

El foro del blog Firebird21

 

Un stored procedure para otorgarle TODOS los derechos a un usuario

6 comentarios

En ocasiones queremos que un usuario (o un rol) tenga todos los derechos sobre una Base de Datos aunque sin ser el SYSDBA de ella ni tener el rol RDB$ADMIN. O quizás lo que necesitamos es que tenga la mayoría de los derechos, aunque no todos.

Para este último caso lo que podríamos hacer es otorgarle todos los derechos y luego quitarle algunos de ellos, para que él tenga solamente los derechos que nosotros queremos que tenga.

Tenemos dos formas de conseguir nuestro objetivo:

  1. La forma lenta
  2. La forma rápida

La forma lenta es por cada tabla, por cada vista y por cada stored procedure otorgarle el derecho correspondiente. Desde luego que si las tablas, vistas y stored procedures se cuentan por decenas o por centenas hacer algo así será terriblemente aburrido y una gran pérdida de tiempo que podríamos aprovechar haciendo algo más productivo.

La forma rápida es a través de un stored procedure como el siguiente:

CREATE PROCEDURE SP_GRANT_ALL_TO(
   tcNombreUsuario VARCHAR(31))
AS
   DECLARE VARIABLE tcObjeto VARCHAR(31);
BEGIN

   -- Se otorga derechos sobre las tablas y sobre las vistas

   FOR SELECT
      RDB$RELATION_NAME
   FROM
      RDB$RELATIONS
   WHERE
      RDB$SYSTEM_FLAG = 0
   INTO
      :tcObjeto
   DO
      EXECUTE STATEMENT 'GRANT ALL ON ' || tcObjeto || ' TO ' || tcNombreUsuario;

   -- Se otorga derechos sobre los stored procedures

   FOR SELECT
      RDB$PROCEDURE_NAME
   FROM
      RDB$PROCEDURES
   WHERE
      RDB$SYSTEM_FLAG = 0
   INTO
      :tcObjeto
   DO
      EXECUTE STATEMENT 'GRANT EXECUTE ON PROCEDURE ' || tcObjeto || ' TO ' || tcNombreUsuario;

END;

 Este stored procedure le otorga al usuario o al rol cuyo nombre introducimos todos los derechos sobre todas las tablas, sobre todas las vistas y sobre todos los stored procedures de nuestra Base de Datos. Lo llamaríamos así:


EXECUTE PROCEDURE SP_GRANT_ALL_TO('MARCELA');

EXECUTE PROCEDURE SP_GRANT_ALL_TO('R_CONTABILIDAD');

COMMIT;

Y cuando el usuario MARCELA o alguien que pertenezca al rol R_CONTABILIDAD vuelva a conectarse a la Base de Datos, tendrá acceso a todas las tablas, todas las vistas y todos los stored procedures.

Conclusión:

Otorgar los derechos (también llamados permisos o privilegios) a cada tabla, cada vista, y cada stored procedure puede ser extremadamente tedioso, sobre todo cuando los objetos no son dos o tres sino decenas o centenas. Evidentemente que lo más inteligente es tener un stored procedure que se encargue de esa tarea por nosotros.

El stored procedure aquí mostrado cumple con esa tarea, aunque desde luego que podría ser mejorado o adaptado a tus particulares circunstancias. Por ejemplo podrías agregarle WITH GRANT OPTION, o podrías colocar un IF …. THEN para que algunos objetos sean salteados y no se otorgue permisos sobre ellos, algo como:

IF (tcObjeto <> 'CONFIGURACION') THEN
   EXECUTE STATEMENT 'GRANT ALL ON ' || tcObjeto || ' TO ' || tcNombreUsuario;

Aquí, si la tabla se llama CONFIGURACION entonces el usuario no recibe derechos en esa tabla. Recibe derechos sobre todas las otras tablas, pero no sobre la tabla CONFIGURACION. Eso puede ser lo más adecuado para evitar que meta sus pezuñas donde no debe.

Otro método es usar el comando REVOKE para quitarle derechos que anteriormente se le habían otorgado. Sería algo como:

REVOKE ALL ON CONFIGURACION FROM MARCELA

Tanto usando IF … THEN como usando REVOKE ALL, se consigue el objetivo buscado, o sea que el usuario MARCELA no tenga derechos sobre la tabla CONFIGURACION.

Ya tú decidirás cual te resulta más conveniente usar.

Advertencia:

El hecho de que PUEDAS fácilmente otorgarle todos los derechos sobre todos los objetos a un usuario usando un stored procedure como el aquí mostrado no significa que DEBAS hacerlo. La seguridad y la integridad de tu Base de Datos siempre debe ser tu principal prioridad; tu comodidad o la comodidad de los usuarios, debe estar después.

Muchas veces lo preferible es que crees un rol (o varios roles) y uno (o varios) archivos de script para el otorgamiento de derechos. Eso tiene la ventaja de que te sirve como documentación (ya que en tu archivo de script puedes escribir todos los comentarios que desees) y que con simples «copiar y pegar» puedes rápidamente tener muchos archivos de script, cada uno de ellos otorgando o revocando derechos.

Por lo tanto, el stored procedure anteriormente mostrado puede ser muy útil pero siempre deberías verificar que no estás otorgando más derechos de los que deberías otorgar.

Artículos relacionados:

Entendiendo los derechos de acceso

Otorgando permisos con EMS SQL Manager

Delegando el otorgamiento de derechos

El índice del blog Firebird21

 

Driver 4.1.5.0 para conectar a Firebird con ADO

2 comentarios

Se ha liberado un driver para conectarse a Firebird usando ADO.NET, la nueva versión es la 4.1.5.0 y puede ser descargada desde:

http://sourceforge.net/projects/firebird/files/firebird-net-provider/4.1.5/

No tiene nuevas características, sino que se han corregido dos bugs y se ha hecho una mejora, como se puede ver en su track aquí:

http://tracker.firebirdsql.org/secure/ReleaseNote.jspa?projectId=10003&styleName=Html&version=10590

Artículos relacionados:

Conectándose con ADO  a las bases de datos

El índice del blog Firebird21

 

Older Entries Newer Entries