Mule es ESB (Enterprise Service Bus) Se usa para enviar/recibir mensajes heterogéneos entre diferentes productos/consumidores.
Admite muchos componentes de transporte y servicio como JMS, SOAP, JBI, BPEL, EJB, AS/400, HTTP, JDBC, TCP, UDP, SMTP, FILE, FTP y más.
Como en Internet el idioma padre es HTTP vamos a ver cómo hacer logging de las peticiones y respuestas HTTP que pasan por mule.
Supongamos que queremos descargar un contenido WEB. Por ejemplo, en la siguiente imagen vemos un caso real de unos XML modelo publicados por la administración pública (pero podría ser una página HTML con sus imágenes, etc.):
La forma de hacerlo usando wget sería:
wget --no-parent -r http[s]://dominio.com/ruta/directorio/descargarCon esto, se crea una carpeta con el nombre del dominio y la estructura de carpetas publicadas en el servidor y todos los documentos referendo los enlaces disponibles desde la ruta indicada.
NOTA: Para poder usar WGET con SSL (https) leer mi post anterior.
***ADICONAL**: Parametros adicionales en https://www.guyrutenberg.com/2014/05/02/make-offline-mirror-of-a-site-using-wget/
WGET es una de esas herramientas prácticamente indispensables para muchos desarrolladores (o incluso usuarios). Al igual que CURL nos facilita la vida con respecto a trabajar con el protocolo HTTP WGET es genial para obtener recursos vía HTTP.
Cuidado GniWin WGET no tiene soporte para SSL!! Esta compilación para Windows (https://sourceforge.net/projects/gnuwin32/files/wget/) ha sido un gran aliado durante muchos años pero no soporta SSL y por desgracia no nos será de ayuda trabajando con HTTPS.
En su lugar podemos descargar (https://eternallybored.org/misc/wget/) esta versión con total soporte a OpenSSL 1.1.1a.
Elegimos la última versión y la arquitectura x32 o x64 (hoy en día, 64 bits lo más probable). A remarcar el soporte SSL, ZLIB (para peticiones comprimidas), etc.
Espero que sea de ayuda!
En ocasiones estamos manejado vistas o elementos de PL/SQL que necesitamos saber que relación existe entre ellos. Para esto oracle nos ofrece la vista user_dependencies que relaciona un objeto (vista, package, function, procedure) con otro si éste es dependencia de otro.
Supongamos una vista ALUMNOS que se usa para hacer consulta, se consume en 1 procedure y 1 function. Si ejecutamos una consulta como la siguiente:
SELECT * FROM user_dependencies
START WITH name = 'ALUMNOS'
CONNECT BY PRIOR TRIM(referenced_name) = TRIM(name);
Obtendremos un resultado como el siguiente, donde veremos en la columna de la izquierda para cada ocurrencia de la izquierda en que elemento de la derecha esta como una dependencia.
Hace unos días tuve una conversación muy recurrente entre desarrolladores de software respecto del uso cotidiano de SQL. ¿Cómo usar JOIN? Esta duda la tienen aún desarrolladores expertos, pues bien vamos a aclarar un poco que es eso del JOIN.
Como breve resumen, decir que JOIN se usa en SQL para combinar filas de dos o más tablas. Y es una sentencia con tantas posibilidades que realmente se merece una explicación en una única entrada de este blog.
Si tomamos cada tabla de la base de datos como un conjunto de datos donde cada columna posee su propio dominio definimos el operador como el JOIN para el conjunto de tuplas a relacionar (no deja de ser una composición):
De modo que R y S son dos tablas, y t y s son filas de cada tabla que se unirán si se cumple la condición dada. Y lo más fácil es ver el siguiente dibujo que representa los diferentes tipos de JOINS que existen conceptualmente (no todas los sistemas gestores de base de datos los soportan) y su representación aproximada como diagrama de Venn:
En este dibujo podemos ver gráficamente la idea de cada tipo de JOIN, filas que se relacionan en ambas tablas (conjuntos), filas que no tengan relación y estén en una tabla pero sí en la otra. O al revés, filas que no estén en la primera tabla y sí en la segundo, y en fin … todas las combinaciones que muestra el gráfico.
Por cierto, si se hace una composición de dos tablas con JOIN y la fila compuesta devuelta es resultado de una relación donde para una tabla hay datos y en la segunda tabla no existe relación, los campos de esa segunda tabla devueltos serám NULL.
Para leer más sobre algebra relacional recomiendo los apuntes de Pedro Pablo Alarcón Cavero [4], buen material docente sin duda. Pero todo esto es mejor analizarlo con un buen ejemplo.
Si accedemos a la Web de W3Schools, tiene una base de datos de ejemplo donde podemos probar online difernetes sentencias SQL [Acceso a la BD en W3Schools].
En este apartado primero vamos a ver una muestra de los datos que contienen las tablas, en la mayoría de casos vamos a ver una SELECT y los primeros registros que devuelve la base de datos, para mas información consultar el enlace “Acceso a la DB de W3Schools”.
select * from Customers
| CustomerID | CustomerName | ContactName | Address | City | PostalCode | Country |
|---|---|---|---|---|---|---|
| 1 | Alfreds Futterkiste | Maria Anders | Obere Str. 57 | Berlin | 12209 | Germany |
| 2 | Ana Trujillo Emparedados y helados | Ana Trujillo | Avda. de la Constitución 2222 | México D.F. | 05021 | Mexico |
| 3 | Antonio Moreno Taquería | Antonio Moreno | Mataderos 2312 | México D.F. | 05023 | Mexico |
(Devuelve 91 clientes)
select * from Employees
| EmployeeID | LastName | FirstName | BirthDate | Photo | Notes |
|---|---|---|---|---|---|
| 1 | Davolio | Nancy | 1968-12-08 | EmpID1.pic | Education includes a BA in psychology from Colorado State University. She also completed (The Art of the Cold Call). Nancy is a member of ‘Toastmasters International’. |
| 2 | Fuller | Andrew | 1952-02-19 | EmpID2.pic | Andrew received his BTS commercial and a Ph.D. in international marketing from the University of Dallas. He is fluent in French and Italian and reads German. He joined the company as a sales representative, was promoted to sales manager and was then named vice president of sales. Andrew is a member of the Sales Management Roundtable, the Seattle Chamber of Commerce, and the Pacific Rim Importers Association. |
(Devuelve 10 empleados)
select * from Shippers
| ShipperID | ShipperName | Phone |
|---|---|---|
| 1 | Speedy Express | (503) 555-9831 |
| 2 | United Package | (503) 555-3199 |
| 3 | Federal Shipping | (503) 555-9931 |
(Devuelve 3 transportistas)
select * from Orders
| OrderID | CustomerID | EmployeeID | OrderDate | ShipperID |
|---|---|---|---|---|
| 10248 | 90 | 5 | 1996-07-04 | 3 |
| 10249 | 81 | 6 | 1996-07-05 | 1 |
| 10250 | 34 | 4 | 1996-07-08 | 2 |
(Devuelve 196 pedidos)
Este es el ejemplo que ofrece W3SChools:
SELECT Orders.OrderID, Customers.CustomerName, Orders.OrderDate FROM Orders INNER JOIN Customers ON Orders.CustomerID=Customers.CustomerID;
| OrderID | CustomerName | OrderDate |
|---|---|---|
| 10248 | Wilman Kala | 1996-07-04 |
| 10249 | Tradição Hipermercados | 1996-07-05 |
| 10250 | Hanari Carnes | 1996-07-08 |
| 10251 | Victuailles en stock | 1996-07-08 |
(Mostramos los 4 primeros, hay 196 resultados)
Ahora vamos a pensar en la tabla clientes y en pedidos. En pedidos se registran los pedidos y qué cliente lo realiza, pero … ¿cómo saber qué clientes no han hecho aún un pedido?
SELECT c.CustomerID AS CodigoCliente, c.CustomerName, o.CustomerID AS ClienteEnPedido FROM Customers AS c LEFT JOIN Orders AS o ON c.CustomerID=o.CustomerID WHERE o.OrderID IS NULL;
| CodigoCliente | CustomerName | ClienteEnPedido |
|---|---|---|
| 1 | Alfreds Futterkiste | null |
| 6 | Blauer See Delikatessen | null |
| 12 | Cactus Comidas para llevar | null |
| 22 | FISSA Fabrica Inter. Salchichas S.A. | null |
| 26 | France restauration | null |
| 32 | Great Lakes Food Market | null |
| 40 | La corne d’abondance | null |
| 42 | Laughing Bacchus Wine Cellars | null |
| 43 | Lazy K Kountry Store | null |
| 45 | Let’s Stop N Shop | null |
| 50 | Maison Dewey | null |
| 53 | North/South | null |
| 57 | Paris spécialités | null |
| 64 | Rancho grande | null |
| 74 | Spécialités du monde | null |
| 78 | The Cracker Box | null |
| 82 | Trail’s Head Gourmet Provisioners | null |
De los 91 clientes que hay, estos 17 no tiene pedidos realizados. Además podemos ver cómo la columna con el ID de cliente en pedidos obtenida con este JOIN vale NULL, con lo que sabemos que existe relación.
Este es otro ejemplo cómo el anterior:
SELECT e.EmployeeID, e.FirstName FROM Employees AS e LEFT JOIN Orders AS o ON e.EmployeeID=o.EmployeeID WHERE o.EmployeeID IS NULL;
| EmployeeID | LastName | FirstName | BirthDate | Photo | Notes |
|---|---|---|---|---|---|
| 10 | West | Adam | 1928-09-19 | EmpID10.pic | An old chum. |
Adam West es el único cliente que no ha registrado pedidos en la base de datos.
Este caso es el mismo que obtener los pedidos de cada cliente, pero añadiendo un flltro por empleado.
SELECT e.EmployeeID, e.FirstName, o.OrderID FROM Employees AS e INNER JOIN Orders AS o ON e.EmployeeID=o.EmployeeID WHERE e.FirstName = 'Nancy';
| EmployeeID | FirstName | OrderID |
|---|---|---|
| 1 | Nancy | 10258 |
| 1 | Nancy | 10270 |
| 1 | Nancy | 10275 |
| 1 | Nancy | 10285 |
| 1 | Nancy | 10292 |
Muestro los 5 primeros pedidos, pero Nancy ha hecho 29 pedidos.
JOIN es una clausula para las consultas SELECT que enrique mucho el lenguaje SQL, permite realizar consultas para diferentes casos muy interesantes sin tener que recurrir a escribir consultas muy complicadas.
Ejemplos para analizar el uso de JOIN hay muchos y en Google podemos encontrar muchos, espero que este resumen sirva de ayuda.
Cuando manipulamos documentos XML [1] desde PHP [2] uno de los “quebraderos” de cabeza son los namespaces. Un namespace no es nada complicado ni rocambolesco como algunos opinan; no deja de ser un enriquecimiento semántico para dotar de más información a un documento XML.
Tradicionalmente los desarrolaldores PHP no se han complicado con este concepto. Pero hoy en día con la cantidad de mensajes y documentos XML que envían mediante REST, SOAP, APIs de terceros, etc. es inevitable y totalmente recomendable conocer como manipularlos de forma sencilla en PHP.
Por lo general cualquier documento XML generado por y para Google tendrá en namespace http://base.google.com/ns/1.0, que simplemente añade algo de información adicional al documento XML (descripciones, items, ….) [4].
Cómo ejemplo vamos a manipular un documento para el servicio Google Shopping [3].
<?xml version="1.0"?>
<rss version="2.0" xmlns:g="http://base.google.com/ns/1.0">
<channel>
<title>El nombre de tu feed de datos</title>
<link>http://www.example.com</link>
<description>Una descripción de tu contenido</description>
<item>
<title>Suéter de lana rojo</title>
<link> http://www.example.com/página-información-producto1.html</link>
<description>Suéter suave y cómodo que te abrigará en las frías noches de
invierno</description>
<g:image_link>http://www.example.com/imagen1.jpg</g:image_link>
<g:price>25</g:price>
<g:condition>nuevo</g:condition>
<g:id>1a</g:id>
</item>
</channel>
</rss>
Si leyéramos este documento directamente con SimpleXML no entendería los namespaces ni sus elementos, quedan este documento:
<?xml version="1.0"?>
<rss version="2.0" xmlns:g="http://base.google.com/ns/1.0">
<channel>
<title>El nombre de tu feed de datos</title>
<link>http://www.example.com</link>
<description>Una descripción de tu contenido</description>
<item>
<title>Suéter de lana rojo</title>
<link> http://www.example.com/página-información-producto1.html</link>
<description>Suéter suave y cómodo que te abrigará en las frías noches de
invierno</description>
</item>
</channel>
</rss>
¿Cómo solucionarlo? Un ejemplo tonto sería la siguiente función que dado un elemento de un documento XML con SimpleXML busca los elementos del namespace http://base.google.com/ns/1.0. Obtenidos los elementos de este namespace en ese nodo, sólo debemos recoger la propiedad deseada (precio).
function xml_get_price(SimpleXMLElement $item)
{
$googleSpace = $item->children('http://base.google.com/ns/1.0');
return $googleSpace->price; // para el ejemplo anterior: 25
}
¡Fin! Espero que sea útil.
En un proyecto reciente he tenido que preparar un sistema de reservas para un hotel. La idea es sencilla poder reservar recursos (en este caso habitaciones) entre unas fechas determinadas.
Pero además, como es un hotel se da una condición especial. La fecha de inicio y de fin no son cerradas, quiero decir que una reserva puede terminar el mismo día que otra empieza y viceversa. Por todos es sabido, que normalmente en un hotel la hora de salida es hasta las 12:00am y la hora de entrada es a partir de las 14:00pm.
¿Cómo resolverlo? Sencillo,veamoslo.
Primero suponemos un esquema tan sencillo como el siguiente:
CREATE SCHEMA IF NOT EXISTS `mydb` DEFAULT CHARACTER SET utf8 COLLATE utf8_general_ci ;
CREATE TABLE IF NOT EXISTS `mydb`.`habitaciones` (
`numero` INT(11) NOT NULL,
`nombre` VARCHAR(45) NULL DEFAULT NULL,
`camas` INT(11) NULL DEFAULT NULL,
`camagrande` TINYINT(1) NULL DEFAULT NULL,
`disponible` TINYINT(1) NULL DEFAULT NULL,
PRIMARY KEY (`numero`))
ENGINE = InnoDB
DEFAULT CHARACTER SET = utf8
COLLATE = utf8_general_ci;
CREATE TABLE IF NOT EXISTS `mydb`.`reservas` (
`reserva_id` INT(11) NOT NULL AUTO_INCREMENT,
`habitaciones_numero` INT(11) NOT NULL,
`entrada` DATE NULL DEFAULT NULL,
`salida` DATE NULL DEFAULT NULL,
`nombrecliente` VARCHAR(45) NULL DEFAULT NULL,
`telefono` VARCHAR(45) NULL DEFAULT NULL,
PRIMARY KEY (`reserva_id`),
INDEX `fk_reservas_habitaciones_idx` (`habitaciones_numero` ASC),
CONSTRAINT `fk_reservas_habitaciones`
FOREIGN KEY (`habitaciones_numero`)
REFERENCES `mydb`.`habitaciones` (`numero`)
ON DELETE NO ACTION
ON UPDATE NO ACTION)
ENGINE = InnoDB
DEFAULT CHARACTER SET = utf8
COLLATE = utf8_general_ci;
El siguiente paso paso sería crear algún dato. Una vez hecho esto, podemos considerar muchos casos posbles, buscando en Internet seguro que hay muchas aproximaciones pero la solución final que yo he encontrado y funciona perfectamente para mi caso es la siguiente:
set @dstart = date_add('2014-03-15', interval 1 day);
set @dend = date_sub('2014-04-01', interval 1 day);
select id, vivienda_id, arrival_date, departure_date, date_add(@dstart, interval 1 day) firstday, date_sub(@dend, interval 1 day) lastday
from espana_reservations r
where (arrival_date between @dstart and @dend)
or (@dstart between arrival_date and departure_date)
Espero que haya sido de ayuda!
Hace poco en un proyecto personal he empezado a usar variables en mis consultas SQL para probarlas en mi cliente HeidiSQL. De esto modo puedo verificar el funcionamiento de las mismas como las construye mi framewoork codeigniter.
Por poner un ejemplo, en PHP plano se escribiría algo así:
$select = 'select * from cosas where precio > ', ($miprecio + $parametro) ' and precio < ', ($miprecio * 10) ;.
Pero claro, lo ideal es poder usar en MySQL una construcción con el mismo aspecto, ¿cómo? Usando las variables que nos ofrece en SQL.
Supongamos una tabla de viviendas con su id, nombre y precio de mercado como la siguiente:
select id, nombre, precio_de_venta from kaza_viviendas| id | nombre | precio_de_venta |
|---|---|---|
| 12 | Villa Atlas | 1470000 |
| 10 | Villa Chronos | 1350000 |
| 11 | Villa Hermes | 780000 |
| 6 | Villa Marfil | 1300000 |
| 8 | Villa Eos | 850000 |
| 9 | Villa Pegasus | 670000 |
Si queremos el precio más bonito y usando otro nombre:
select id, nombre, format(precio_de_venta, 2) as precio from viviendas
| id | nombre | precio |
|---|---|---|
| 12 | Villa Atlas | 1,470,000.00 |
| 10 | Villa Chronos | 1,350,000.00 |
| 11 | Villa Hermes | 780,000.00 |
| 6 | Villa Marfil | 1,300,000.00 |
| 8 | Villa Eos | 850,000.00 |
| 9 | Villa Pegasus | 670,000.00 |
A continuación, vamos a crear dos parámetros “horquilla” y “precio_referencia”. El primero establece un límite sobre el que buscar precio “similares” al dado por “precio_referencia”:
set @precio_referencia=1470000;
set @horquilla=25000;
select id, nombre, format(precio_de_venta, 2) as recio
from viviendas
where precio_de_venta >= (@precio_referencia - @horquilla)
and precio_de_venta <= (@precio_referencia + @horquilla);
Como vemos sólo nos devuelve una. Pero para generar y probar una lista de viviendas similares con este u otro criterio resulta muy útil y rápido
| id | nombre | recio |
|---|---|---|
| 12 | Villa Atlas | 1,470,000.00 |
Estos ejemplos son muy sencillo y tontos, pero creo que ilustran a grandes rasgos lo que quiero decir, además estoy seguro que para construir consultas más complejos con mayor cantidad de cruzas y condiciones podría ser de gran ayuda.
En desarrollo personalmente no me gusta usar variables de MySQL, aunque con ejemplos como el anterior si que veo muy claro lo que facilita la depuración del SQL y ayuda a la hora de construir consultas muy complejas con muchos datos cruzas y poder probar diferentes casos.
Hace poco tuve que realizar unas pruebas en un proyecto y necesitaba desactivar el javascript para hacer unas comprobaciones. ¿Cómo hacer esto en Firefox?
Muy fácil, en la barra de direcciones escribimos “about:config”, nos preguntará el navegador si de verdad queremos acceder. Le respondemos que sí. Ahora estamos en el núcleo de la configuración de firefox, debemos llevar cuidado.
Buscamos la clave “javascript.enabled”. La ponemos a FALSE e voilá! El navegador no interpretará Javascript.
Como desarrollador Web en alguna ocasión he tenido que realizar algún proyecto sin disponibilidad de tener un servidor de desarrollo. Hasta este punto, existen tres opciones si queremos trabajar con un servidor de desarrollo en lugar de usar un WAMP o un XAMPP (que son cómodos pero poco profesionales).
En esta entrada me voy a decantar por esta última opción por comodidad y rapidez. Pero hay que tener en cuenta que esta solución sólo servirá para tener un entorno multihost para uno mismo, si se trabaja en grupo en un red no será un sistema válido.
Lo primero, es instalar un sistema LAMP (Linux, Apache, Mysql, PHP). Esto en un sistema Debian/Ubuntu es tan sencillo cómo ejecutar en consola:
$ sudo apt-get install apache2 apache2-mpm-worker apache2-utils apache2.2-bin apache2.2-common libaprutil1-dbd-sqlite3 libaprutil1-ldap libhtml-template-perl mysql-server mysql-server-5.5 mysql-server-core-5.5 apache2-mpm-prefork libapache2-mod-php5 libtidy-0.99-0 php5 php5-cli php5-common php5-curl php5-gd php5-mysql php5-odbc php5-sqlite php5-tidy php5-xdebug php5-xmlrpc libapache2-mod-auth-mysql libphp-jpgraph dbconfig-common libmcrypt4 php-doc php5-mcrypt phpmyadmin
A continuación, como sana costumbre recomiendo cambiar la clave de root de MySQL.
mysql -u root
mysql> SET PASSWORD FOR 'root'@'localhost' = PASSWORD('yourpassword');
Y por último, si hemos instalado PHP, editar el fichero /etc/php5/apache2/php.ini y habilitar el uso de mysql, en la línea:
;extension=mysql.so Cambiadla por: 1extension=mysql.so
Apache2 se configura de modo que se le indica al servidor en que interfaces de red y puertos debe funcionar. Tomemos la imagen siguiente:
Disponemos de varios nombres de dominio (reales o ficticios) y deseamos que apunten a la misma máquina, pero claro, no queremos que apache nos facilite las mismas Webs para cada uno, sino que sean proyectos diferentes (multihost), para ello debemos indicar el sistema DNS que esos nombres apuntan a la IP del servidor de trabajo.
Si estuviéramos en un entorno real y profesional, tendríamos un servidor DNS y un servidor LAMP dedicado con una IP W.X.Y.Z, e indicaríamos al servidor DNS que cada dominio apunte al servidor con IP W.X.Y.Z. Como estamos probando en un servidor “monopuesto” no necesitamos configurar ningún servidor DNS, sólo debemos editar el fichero /etc/hosts. Este fichero es una reminiscencia del origen de Internet y contiene parejas del tipo (nombre, ip).
De modo que si queremos añadir el dominio de prueba “midominio”, sólo debemos añadir al final del fichero /etc/hosts la sighuiente línea:
127.0.0.1 midominio
Una vez hecho esto, nuestro equipo sabe que la IP del dominio midominio es 127.0.0.1. Pero, sólo nuestro equipo, este fichero es local al equipo dónde lo hemos editado de ahí que este sistema sólo nos sirva para el equipo de trabajo no para trabajar en equipo.
Y por fin, vamos a ver los pasos para configurar un sistema multihost en nuestro apache2. Supongamos que los DocumentRoot de los diferentes dominios estan en la carpeta /home/usuario/www, debemos seguir estos pasos:
$ sudo usermod -G www-data USUARIO
$ find $PWD -type d -print -exec chmod 775 {} \;
$ find $PWD -type f -print -exec chmod 664 {} \;
$ sudo chown -R USUARIO:www-data *
<VirtualHost *:80>
ServerAdmin info@miemail.com
Servername midominio
DocumentRoot /home/usuario/www/midominio
LogLevel warn
ErrorLog ${APACHE_LOG_DIR}/midominio_error.log
CustomLog ${APACHE_LOG_DIR}/midominio_access.log combined
<Directory />
Options FollowSymLinks
AllowOverride None
</Directory>
<Directory /home/usuario/www/midominio>
Options Indexes FollowSymLinks MultiViews
AllowOverride All
Order allow,deny
allow from all
</Directory>
</VirtualHost>Debemos tener cuidado con lo siguiente, en Debian/Ubuntu la configuración inicial de apache2 desactiva el uso del fichero .htaccess. Para habilitarlo debemos ser cuidadods de poner la directiva AllowOverride All como en el ejemplo anterior.
Novedad: En versiones recientes de apache está configuración puede no ser suficiente y debemos añadir alguna directiva adicional, para no encontrartos un error HTTP 403 Forbbiden. De modo que en la configuración del directorio con el DOCUMENT ROOT debemos a Require all granted, quedando algo así
:
<Directory "your directory here"> Order allow,deny Allow from all # New directive needed in Apache 2.4.3: Require all granted
Tal y como podemos leer en Stack Overflow.
$ sudo a2enmod rewrite $ sudo service apache2 restart
Suerte con vuestros servidores LAMP!