{"id":362,"date":"2015-09-25T09:05:27","date_gmt":"2015-09-25T08:05:27","guid":{"rendered":"http:\/\/tecnologiasweb.jsenso.es\/?p=362"},"modified":"2015-09-25T09:05:27","modified_gmt":"2015-09-25T08:05:27","slug":"sql-para-bibliotecarios","status":"publish","type":"post","link":"https:\/\/blogs.ugr.es\/tecweb\/sql-para-bibliotecarios\/","title":{"rendered":"Introducci\u00f3n a SQL para bibliotecarios"},"content":{"rendered":"

Recientemente Ruth Kitchin Tillman<\/a>, bibliotecaria experta en el trabajo con metadatos, public\u00f3 en su blog una entrada muy interesante en la que realizaba una breve introducci\u00f3n al lenguaje de consulta SQL pensada para bibliotecarios<\/a>. Como me pareci\u00f3 una idea muy buena, me puse en contacto con ella para ver si me permit\u00eda traducir su post y adaptarlo a la realidad espa\u00f1ola. Algo a lo que ella ha accedido de manera muy amable.<\/p>\n

En un principio entend\u00eda que a mis alumnos les vendr\u00eda muy bien una introducci\u00f3n de este tipo a modo de refresco de lo que, se supone, saben. Como soy consciente de que la mayor\u00eda de ellos est\u00e1 peleado con el ingl\u00e9s, he optado por la adaptaci\u00f3n. Es decir, no traducir\u00e9 de manera literal el texto de Ruth, sino que lo adaptar\u00e9 a nuestras necesidades. Entiendo que esto tambi\u00e9n le vendr\u00e1 bien a aquellos que no sean alumnos m\u00edos.<\/p>\n

La verdad es que SQL es un lenguaje de consulta bastante sencillo de aprender, pero no por eso deja de ser menos potente. En realidad permite realizar todas las operaciones que se nos ocurran sobre una o varias bases de datos. Evidentemente, el sentido de esta entrada no es la de profundizar en este lenguaje, ya que ser\u00edan necesarias muchas entradas en este blog. Adem\u00e1s, partir\u00e9 del hecho de que la mayor\u00eda de mis lectores son expertos en b\u00fasquedas en bases de datos, tal y como se le presupone a un bibliotecario. No obstante, al igual que Ruth, recomiendo la lectura del libro de Michael J. Hernandez, Database Design for Mere Mortals<\/a>. Para espa\u00f1ol, siempre me vino bien el libro de Alan Beaulieu titulado Aprende SQL<\/a>, de la editoral O’Reilly.<\/p>\n

Conocer el lenguaje de consulta SQL es fundamental para cualquier bibliotecario (y, por extensi\u00f3n, archiveros, claro). En el momento en el que estamos trabajando con bases de datos, conocer c\u00f3mo podemos manipular f\u00e1cilmente gran cantidad de registros para modificarlos, buscar, editarlos\u2026 es fundamental. Adem\u00e1s, cualquier profesional de la informaci\u00f3n que se mueva dentro de un entorno web, o que est\u00e9 relacionado con la arquitectura de la informaci\u00f3n web, al igual que le sucede a mis alumnos de la asignatura \u201cTecnolog\u00edas web para servicios de informaci\u00f3n\u201d, cuantos m\u00e1s conocimientos tenga de c\u00f3mo se organiza la informaci\u00f3n en las bases de datos y de c\u00f3mo gestionar la informaci\u00f3n desde el back-end del sistema, mejor.<\/p>\n

En el caso de la entrada de Ruth, ella nos cuenta que, al ser su \u00e1rea de trabajo la gesti\u00f3n de metadatos, emplea SQL para realizar consultas con el fin de extraer los metadatos de sus bases de datos, introducirlos en hojas de c\u00e1lculo, enriquecerlos y, a continuaci\u00f3n y por medio de consultas de actualizaci\u00f3n, mejorar los registros del sistema.<\/p>\n

Preliminares: lo que debes saber.<\/h2>\n

SQL tiene dialectos, que dependen de la instalaci\u00f3n con la que est\u00e9s trabajando<\/b>. SQL es un lenguaje gen\u00e9rico, pero puede presentar variaciones dependiendo del software que se est\u00e9 empleando. En esta entrada vamos a hablar de bases de datos MySQL<\/a>, pero tambi\u00e9n se puede usar PostgreSQL<\/a> o SQL Server<\/a>. Cada una de ellas usa un dialecto diferente de SQL. En realidad hay pocas diferencias desde el punto de vista del lenguaje<\/a> y del software<\/a>, pero no merece la pena complicarse demasiado con este tema.<\/p>\n

\u00bfPor qu\u00e9 comillas abiertas? \u00bfPor qu\u00e9 solo en ocasiones?<\/b> Es posible que, alguna vez, veas sentencias como esta: SELECT `comment_author` FROM `wp_comments`<\/span><\/span><\/span>. En MySQL las comillas abiertas se emplean para indicar que una frase es un tipo de identificador: el nombre de una base de datos, el de una tabla o, incluso, el de un campo. De esa manera es posible emplear palabras como `from` <\/span><\/span><\/span>como si fueran un nombre, sin causar errores de sintaxis. En esta entrada las emplearemos para indicar que estamos hablando de una base de datos\/tabla\/campo, pero no se usar\u00e1n en los c\u00f3digos que pongamos de ejemplo, que estar\u00e1n hechos en SQL a secas. Otra cuesti\u00f3n con respecto a las comillas en SQL. Puede resultar algo desconcertante, pero se pueden emplear 3 tipos. Las comillas dobles (\u201c) se emplean para delimitar identificadores (nombre de una tabla, de un campo…). Las comillas simples (‘) se usan para cadenas de caracteres. Por \u00faltimo las que en ingl\u00e9s se denominan backticks y que en espa\u00f1ol se han traducido por comillas abiertas o, en ocasiones, comillas de ejecuci\u00f3n.<\/p>\n

\u00bfPor qu\u00e9 tenemos que saber SQL?<\/h2>\n

La primera respuesta es bastante clara: porque una parte importante de nuestro trabajo se centra en buscar informaci\u00f3n. Una vez que tenemos claro lo que queremos, el siguiente paso es ir a la interfaz correspondiente y rellenar los campos que necesitamos. En muchas ocasiones esas consultas que realizamos no difieren demasiado de lo que se deber\u00eda hacer en SQL. De hecho, cuando vas a una base de datos e introduces en el campo \u201ct\u00edtulo del art\u00edculo\u201d los datos correspondientes al t\u00edtulo del art\u00edculo que est\u00e1s buscando has seguido, en esencia, un proceso similar al que se realizar\u00eda en SQL. Otro ejemplo lo tienes en los informes que le solicitas a tu programa de automatizaci\u00f3n de bibliotecas.<\/p>\n

Podr\u00edamos decir que ya sabes lo que quieres, c\u00f3mo y d\u00f3nde buscarlo. Lo que ahora necesitas es conocer el lenguaje en el que expresar todo eso. Y a ah\u00ed es donde vamos ahora.<\/p>\n

Conoce tu base de datos<\/h2>\n

Asumiendo que tienes la posibilidad de realizar b\u00fasquedas en una base de datos, es evidente que necesitas saber sobre qu\u00e9 campos est\u00e1s realizando esa consulta. Por ejemplo, imagina buscar en JSTOR<\/a>. Sabes que puedes hacer consultas tanto en la interfaz b\u00e1sica como en la avanzada. En ambas opciones tienes la posibilidad de buscar en los campos (autor, t\u00edtulo, materia\u2026) que te convengan en funci\u00f3n de tus necesidades. E, incluso, si no est\u00e1s familiarizado con esta base de datos, puedes seguir consult\u00e1ndola de manera sencilla porque todas las opciones de b\u00fasqueda se visualizan en una \u00fanica pantalla. En SQL sucede algo parecido aunque, para ser sinceros, la organizaci\u00f3n de los campos y de la informaci\u00f3n no siempre es tan evidente.<\/p>\n

Todas las bases de datos contienen m\u00faltiples tablas, organizadas en funci\u00f3n del tipo de dato que almacenar\u00e1n, como `omeka_options`<\/code><\/span><\/span><\/span>o <\/span><\/span><\/span>`accessions`<\/code><\/span><\/span><\/span>.<\/span><\/span><\/span> Las tablas contienen campos, de manera muy similar a como sucede en las columnas de la hoja de c\u00e1lculo Excel. En, por ejemplo, una tabla sencilla nos podemos encontrar un campo para el t\u00edtulo del libro, otro para la fecha de publicaci\u00f3n, para el \u00edndice\u2026<\/p>\n

Existen dos formas de averiguar qu\u00e9 tablas tiene una base de datos y qu\u00e9 campos contiene, lo que te ayudar\u00e1 a formarte una idea de qu\u00e9 informaci\u00f3n guarda cada tabla.<\/p>\n

Empleo de una interface.<\/h3>\n

La mayor\u00eda de interfaces permite mostrar la informaci\u00f3n de las tablas de manera visual, muy amigable para el usuario. Uno de las herramientas m\u00e1s empleadas en este sentido es phpMyAdmin<\/a>. Se trata de un software gratuito que se encuentra integrado en la mayor\u00eda de soluciones XAMPP<\/a> y servicios de hosting, aunque tambi\u00e9n se puede instalar de manera individual.<\/p>\n

\"Lista<\/a>Como podemos ver en la imagen, si selecciono una base de datos en la parte de la derecha aparecer\u00e1n las tablas y sus caracter\u00edsticas. Si selecciono una tabla se pueden ver los campos, as\u00ed como los registros de cada tabla. Eso me da una idea de lo que tengo por delante.<\/p>\n

\"Despu\u00e9s<\/a>Si te fijas, en la parte superior de la pantalla aparece una sentencia SQL que es, en realidad, la que se ha empleado para generar la p\u00e1gina que estoy visualizando.<\/p>\n

\"phpMyAdmin<\/a><\/p>\n

Consultado informaci\u00f3n detallada de la tabla.<\/p>\n

Es posible obtener informaci\u00f3n m\u00e1s detallada si ejecutamos una consulta en MySQL. Si, por ejemplo, escribo:<\/p>\n\n\n<\/colgroup>\n\n\n
\n
SHOW<\/span><\/b><\/span><\/span><\/span> TABLES<\/b><\/span>;<\/span><\/span><\/span><\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
El cliente responder\u00e1 con una lista de todas las tablas de la base de datos, de tal forma que ya sabremos sus nombres.<\/p>\n
A continuaci\u00f3n necesitamos saber, adem\u00e1s del nombre de los campos, algo de informaci\u00f3n sobre el tipo de dato que contienes. Para eso, y empleando el nombre de la tabla, ejecutamos la orden:<\/p>\n\n\n<\/colgroup>\n\n\n
 
\n
DESCRIBE<\/span><\/b><\/span><\/span><\/span> omeka_options<\/b><\/span>;<\/span><\/span><\/span><\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
Y obtenemos<\/p>\n
\"Configuraci\u00f3n<\/a>La primera columna muestra el nombre del campo, la segunda nos dice el tipo de dato que acepta dicho campo. Cuando se est\u00e1 empezado, con conocer estos dos datos (adem\u00e1s de la llave) es suficiente. La tercera columna nos dice si ese campo puede estar vac\u00edo o no. La cuarta muestra el tipo de llave con la que se trabaja en cada campo. Hablar de esto supondr\u00eda una entrada nueva, as\u00ed que no entraremos demasiado a profundizar en este tema. De hecho, para hacer consultas sencillas no necesitas conocer el tipo de llave de cada campo. La quinta columna indica si existe alg\u00fan valor predeterminado (como verdadero o falso). En nuestro ejemplo, ning\u00fan campo tiene valores de este tipo. La \u00faltima columna indica que el campo id se alimenta autom\u00e1ticamente, con un n\u00famero integral, de manera incremental.<\/p>\n
 <\/p>\n
Consulta de ejemplo<\/h3>\n
Cuando antes se coment\u00f3 la existencia de phpMyAdmin se emple\u00f3 una b\u00fasqueda determinada. La manera m\u00e1s sencilla de obtener algo parecido es ejecutar lo siguiente:<\/p>\n\n\n<\/colgroup>\n\n\n
 
\n
  SELECT<\/b><\/span><\/span><\/span> *<\/span><\/span><\/span><\/span>\n FROM<\/b> TABLE_NAME<\/b><\/span><\/span><\/span><\/span>\n L<\/b><\/span><\/span><\/span>I<\/b><\/span><\/span><\/span>MIT<\/b><\/span><\/span><\/span> 25<\/span><\/span><\/span><\/span><\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
El resultado de esta b\u00fasqueda en un listado con las 25 primeras entradas de la tabla. M\u00e1s adelante explicar\u00e9 cada uno de los elementos que componen esta consulta. Con esa b\u00fasqueda puedo saber, por ejemplo, que existe un campo que se denomina `location`<\/span><\/span><\/span> que usa el valor \u201cnuevo\u201d cuando se adquiere un libro nuevo, o el valor \u201csl2\u201d cuando el libro est\u00e1 en la segunda estanter\u00eda, etc. Esta informaci\u00f3n me permitir\u00e1 construir b\u00fasquedas m\u00e1s adelante.<\/p>\n
 <\/p>\n
Escribir, escribir, escribir<\/h2>\n
Si est\u00e1s haciendo una b\u00fasqueda es, posiblemente, porque necesites algo. A lo mejor es informaci\u00f3n. Quiz\u00e1 quieras hacer una hoja de c\u00e1lculo con algunos datos. O puede que necesites una lista de t\u00edtulos de documentos con una caracter\u00edstica especial. O un art\u00edculo del que s\u00f3lo conoces el DOI.<\/p>\n
A pesar de llevar muchos a\u00f1os usando SQL, a\u00fan siento la necesidad de anotar, de ayudarme con un lapiz y un papel en mis consultas. Especialmente si son complicadas. Emplea lo que has escrito en tus anotaciones para construir las ecuaciones de b\u00fasqueda. Esas notas te ayudar\u00e1n a comprender mejor c\u00f3mo tienes que expresar tu b\u00fasqueda, y ajustarla a la sintaxis de SQL.<\/p>\n
 <\/p>\n
Ahora, vamos a buscar.<\/h2>\n
Por fin vamos a construir nuestra b\u00fasqueda. Para ello es necesario comprender algunos elementos que son importantes. Lo primero es entender dos clausulas b\u00e1sicas: SELECT y FROM.<\/p>\n
SELECT<\/b>. En realidad hace exactamente eso, seleccionar datos con los que trabajar. No se dedica a actualizar, eliminar o insertar. En la mayor\u00eda de ocasiones se emplea para seleccionar el nombre del campo con el que trabajar. Si se desea consultar varios campos, se separan por comas. Si se desea consultar todos los campos de una tabla se usa *. Se puede refinar SELECT a\u00f1adi\u00e9ndole *, tal y como hicimos en la primera consulta de esta entrada, y, despu\u00e9s, decidir qu\u00e9 campo es el que te interesa.<\/p>\n
FROM<\/b>. Sirve para indicar el nombre de la tabla, generalmente, de la forma `table_name`<\/code><\/span><\/span><\/span>, <\/span><\/span><\/span>aunque, en ocasiones, puede ser `database_name`.`table_name`<\/code><\/span><\/span><\/span>. Lo que acabamos de hacer se denomina periodo, y se pueden emplear, entre otras cosas, para unir bases de datos, tablas y campos en b\u00fasquedas concretas. En realidad esto s\u00f3lo se hace cuando se consultan varias bases de datos y varias tablas.<\/p>\n
En las consultas, la expresi\u00f3n m\u00e1s habitual es WHERE.<\/p>\n
WHERE<\/b>. Se emplea para limitar. Se puede usar un solo WHERE (ver AND\/OR m\u00e1s adelante), como veremos en el siguiente ejemplo. En \u00e9l se emplea WHERE para especificar que s\u00f3lo queremos aquellos libros publicados en 2015. Observa que no hemos especificado el campo `publication_date` <\/span><\/span><\/span>con SELECT. Una b\u00fasqueda se puede referir a cualquier campo en cualquier tabla donde est\u00e9s ejecutando la consulta.<\/p>\n\n\n<\/colgroup>\n\n\n
 
\n
SELECT<\/span><\/b><\/span><\/span><\/span> title<\/span><\/span><\/span>\nFROM<\/span><\/b><\/span><\/span><\/span> books<\/span><\/span><\/span>\nWHERE<\/span><\/b><\/span><\/span><\/span> publication_date =<\/span> '2015'<\/span>;<\/span><\/span><\/span><\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
 <\/p>\n
Con WHERE se pueden usar gran cantidad de operadores de comparaci\u00f3n, tales como < > != <> !< !> <= >=<\/span><\/span><\/span>. Aqu\u00ed tienes una explicaci\u00f3n<\/a> bastante buena sobre el uso concreto de cada uno de ellos.<\/p>\n
Adem\u00e1s, se pueden usar operadores l\u00f3gicos, como LIKE, IS NULL, IS UNIQUE, EXISTS y BETWEEN. Aqu\u00ed tienes una explicaci\u00f3n<\/a> sobre el uso de cada uno.<\/p>\n
Despu\u00e9s de WHERE se puede usar AND, OR y NOT. Se consideran cl\u00e1usulas de WHERE porque no se pueden usar sin esa expresi\u00f3n.<\/p>\n
AND<\/b>. A todos nos resulta bastante conocido su uso. Se pueden emplear tantos como sean necesarios para la b\u00fasqueda. Imagina que deseas hacer una consulta de todos los documentos publicados en 2015 por la editorial Simon & Shuster:<\/p>\n\n\n<\/colgroup>\n\n\n
 
\n
SELECT<\/span><\/b><\/span><\/span><\/span> title<\/span><\/span><\/span>\nFROM<\/span><\/b><\/span><\/span><\/span> books<\/span><\/span><\/span>\nWHERE<\/span><\/b><\/span><\/span><\/span> publication_date =<\/span> '2015'<\/span><\/span><\/span><\/span>\nAND<\/span><\/b><\/span><\/span><\/span> publisher =<\/span> 'Simon & Shuster'<\/span>;<\/span><\/span><\/span><\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
OR<\/b>. Al igual que le anterior, se pueden usar tantos como sean necesarios. Sup\u00f3n que necesitas localizar todos los libros que sean de 2015 o que est\u00e9n etiquetados como nuevos:<\/p>\n\n\n<\/colgroup>\n\n\n
 
\n
SELECT<\/span><\/b><\/span><\/span><\/span> title<\/span><\/span><\/span>\nFROM<\/span><\/b><\/span><\/span><\/span> books<\/span><\/span><\/span>\nWHERE<\/span><\/b><\/span><\/span><\/span> publication_date =<\/span> '2015'<\/span><\/span><\/span><\/span>\nOR<\/span><\/b><\/span><\/span><\/span> location =<\/span> 'new'<\/span>;<\/span><\/span><\/span><\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
NOT<\/b>. Al contrario que los otros operadores, NOT necesita que se emplea junto a WHRER, AND u OR. Si queremos los libros publicados en 2015 pero que no han sido colocados a\u00fan en el apartado de nuevos:<\/p>\n\n\n<\/colgroup>\n\n\n
 
\n
SELECT<\/span><\/b><\/span><\/span><\/span> title<\/span><\/span><\/span>\nFROM<\/span><\/b><\/span><\/span><\/span> books<\/span><\/span><\/span>\nWHERE<\/span><\/b><\/span><\/span><\/span> publication_date =<\/span> '2015'<\/span><\/span><\/span><\/span>\nAND<\/span><\/b><\/span><\/span><\/span> NOT<\/b><\/span> location =<\/span> 'new'<\/span>;<\/span><\/span><\/span><\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
Tambi\u00e9n se puede emplear != o <>, de la forma location != ‘new’.<\/span><\/span><\/span><\/p>\n
Evidentemente, se pueden anidar AND, OR y NOT dentro de par\u00e9ntesis. Si queremos algo de la editorial Simon & Shuster de 2015, pero no tenemos claro si lo han escrito as\u00ed o de la forma \u201cSimon and Shuster\u201d, la ecuaci\u00f3n ser\u00eda:<\/p>\n\n\n<\/colgroup>\n\n\n
 
\n
SELECT<\/span><\/b><\/span><\/span><\/span> title<\/span><\/span><\/span>\nFROM<\/span><\/b><\/span><\/span><\/span> books<\/span><\/span><\/span>\nWHERE<\/span><\/b><\/span><\/span><\/span> publication_date =<\/span> '2015'<\/span><\/span><\/span><\/span>\nAND<\/span><\/b><\/span><\/span><\/span> (<\/span>publisher =<\/span> 'Simon & Shuster'<\/span> OR<\/b><\/span> publisher=<\/span>'Simon and Shuster'<\/span>)<\/span>;<\/span><\/span><\/span><\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
Existen otros dos elementos que permiten gestionar los resultados de manera muy eficaz:<\/p>\n
LIMIT<\/b>. Permite controla la cantidad de resultados a visualizar tras una b\u00fasqueda. Un l\u00edmite de 25 es bastante aceptable. E, incluso, puedes poner un l\u00edmite de 0,25 (SQL comienza a contar en el 0). Si necesitas m\u00e1s registros, tan solo tienes que volver a ejecutar la misma consulta, pero indicando el l\u00edmite 26, 50 para obtener el siguiente conjunto. Este mecanismo es muy \u00fatil cuando lo que necesitas es s\u00f3lo un grupo de documentos de muestra. De esa forma no saturas el servidor.<\/p>\n
En los ejemplos que se han empleado aqu\u00ed, phpMyAdmin aplica autom\u00e1ticamente LIMIT 0, 30 siempre y cuando no se personalice esta opci\u00f3n. En mi trabajo suelo hacer LIMIT 0, 1000 y, despu\u00e9s 1001, 2000. Si el servidor con el que est\u00e1s trabajando tiene mucha carga de trabajo, lo mejor es limitar a n\u00fameros bajos.<\/p>\n
ORDER BY<\/b>. Permite especificar qu\u00e9 hacer con los resultados. Al igual que la clausula WHERE, no es necesario que aparezca en la lista de campos que has seleccionado. La ordenaci\u00f3n puede ser ascendente (ASC, que se hacer por defecto) o descendente (DESC).<\/p>\n\n\n<\/colgroup>\n\n\n
 
\n
SELECT<\/span><\/b><\/span><\/span><\/span> title<\/span><\/span><\/span>\nFROM<\/span><\/b><\/span><\/span><\/span> books<\/span><\/span><\/span>\nWHERE<\/span><\/b><\/span><\/span><\/span> publication_date =<\/span> '2015'<\/span><\/span><\/span><\/span>\nOR<\/span><\/b><\/span><\/span><\/span> location =<\/span> 'new'<\/span><\/span><\/span><\/span>\nORDER<\/span><\/b><\/span><\/span><\/span> BY<\/b><\/span> publication_date DESC<\/b><\/span>;<\/span><\/span><\/span><\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
 <\/p>\n
A modo de resumen<\/h2>\n
Esto es todo. Ahora vamos a recordar lo esencial.<\/p>\n
    \n
  1. Para construir una ecuaci\u00f3n de b\u00fasqueda en SQL, lo primero que necesitas es saber un poco sobre c\u00f3mo es la base de datos que est\u00e1s consultando.<\/li>\n
  2. Luego, ten claro lo que quieres. Localiza en qu\u00e9 tablas y campos puede encontrarse esa informaci\u00f3n.<\/li>\n
  3. Anota todos tus pasos y la informaci\u00f3n que pueda ser importante<\/li>\n
  4. y, para finalizar, refina la b\u00fasqueda teniendo en cuenta las opciones de sintaxis que ofrece el lenguaje.<\/li>\n<\/ol>\n
    En pr\u00f3ximos tutoriales tratar\u00e9 cosas como \u201cc\u00f3mo puedo obtener datos de dos tablas\u201d o \u201c\u00bfqu\u00e9 es una llave?\u201d. Aunque creo que ser\u00e1n entradas m\u00e1s cortas que esta, y seguramente har\u00e1n referencia a ella. Existen gran cantidad de sitios con informaci\u00f3n parecida, pero no abordan el tema de la manera que yo pretend\u00eda aqu\u00ed. No obstante, espero que esta sea una buena referencia para vosotros. Lo que realmente intento es que, con este tutorial, SQL sea algo menos confuso.<\/p>\n
     <\/p>\n
     <\/p>\n","protected":false},"excerpt":{"rendered":"
    Recientemente Ruth Kitchin Tillman, bibliotecaria experta en el trabajo con metadatos, public\u00f3 en su blog una entrada muy interesante en la que realizaba una breve introducci\u00f3n al lenguaje de consulta SQL pensada para bibliotecarios. Como me pareci\u00f3 una idea muy buena, me puse en contacto con ella para ver si me permit\u00eda traducir su post […]<\/p>\n","protected":false},"author":65,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_genesis_hide_title":false,"_genesis_hide_breadcrumbs":false,"_genesis_hide_singular_image":false,"_genesis_hide_footer_widgets":false,"_genesis_custom_body_class":"","_genesis_custom_post_class":"","_genesis_layout":"","footnotes":""},"categories":[43],"tags":[82,50,42,83],"class_list":{"0":"post-362","1":"post","2":"type-post","3":"status-publish","4":"format-standard","6":"category-software-de-clase","7":"tag-base-de-datos","8":"tag-mysql","9":"tag-servidores-web","10":"tag-sql","11":"entry"},"_links":{"self":[{"href":"https:\/\/blogs.ugr.es\/tecweb\/wp-json\/wp\/v2\/posts\/362","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/blogs.ugr.es\/tecweb\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/blogs.ugr.es\/tecweb\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/blogs.ugr.es\/tecweb\/wp-json\/wp\/v2\/users\/65"}],"replies":[{"embeddable":true,"href":"https:\/\/blogs.ugr.es\/tecweb\/wp-json\/wp\/v2\/comments?post=362"}],"version-history":[{"count":0,"href":"https:\/\/blogs.ugr.es\/tecweb\/wp-json\/wp\/v2\/posts\/362\/revisions"}],"wp:attachment":[{"href":"https:\/\/blogs.ugr.es\/tecweb\/wp-json\/wp\/v2\/media?parent=362"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/blogs.ugr.es\/tecweb\/wp-json\/wp\/v2\/categories?post=362"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/blogs.ugr.es\/tecweb\/wp-json\/wp\/v2\/tags?post=362"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}