Database

Crear un usuario y asignar permisos en MySQL

root — Thu, 06 Sep 2018 17:20:10 +0000

Crear un usuario y asignar permisos en MySQL

Jueves, Septiembre 6, 2018 - 19:20

Normalmente para configurar el acceso de una aplicación web a la base de datos crearemos una cuenta de servicio para esa aplicación, y le daremos permisos según necesitemos, pero solamente a esa base de datos.

Esta es una de esas cosas que uno hace mil veces pero nunca se acuerda de la sintaxis correcta. Aqui lo teneis:

CREATE USER 'nombre_de_usuario'@'localhost' IDENTIFIED BY 'vuestra_password';
GRANT ALL PRIVILEGES ON nombre_de_base_de_datos.* TO 'nombre_de_usuario'@'localhost';
FLUSH PRIVILEGES;

Si queremos asignarle todos los permisos para todas las bases de datos, el GRANT sería así:

GRANT ALL PRIVILEGES ON *.* TO 'nombre_de_usuario'@'localhost';

Normalmente, antes habremos creado la base de datos a mano, o importando los datos de algún archivo. Crear la base de datos en MySQL puede ser tan sencillo como:

CREATE DATABASE nombre_de_base_de_datos;

Suele ser buena idea probar que ha funcionado correctamente. La mejor forma es probar el acceso usando el terminal:

mysql --user=nombre_de_usuario --password=vuestra_password nombre_de_base_de_datos

Si todo está correcto, nos abrirá una sesión de MySQL en el terminal. Si no conecta, es que hemos hecho mal alguno de los pasos anteriores.

Añadir nuevo comentario

Acceso a base datos en Drupal 7. Parte 2

root — Fri, 17 Nov 2017 21:26:38 +0000

Acceso a base datos en Drupal 7. Parte 2

Viernes, Noviembre 17, 2017 - 22:26

Drupal

Database

Issues

Continuamos con el ejemplo de acceso a base de datos en Drupal 7 que comenzamos hace unos días. Puedes consultar la primera parte del artículo para refrescar o si simplemente te la perdiste.

En esta segunda parte vamos a ver cómo:

Crear un formulario para que el usuario pueda crear un nuevo registro en nuestra tabla de issues.
Usar el mismo formulario para modificar los datos de una incidencia.
Eliminar el registro de una incidencia de la tabla.

Definir Hook menus para las acciones

Lo primero que vamos a hacer es ampliar nuestra implementación de hook_menu() para declarar las tres URLs nuevas que necesitamos:

Una URL para modificar los datos de una incidencia: /issues/edit/[issue_id]
Otra para eliminar incidencias de la tabla: /issues/delete/[issue_id]
Por último, para dar de alta incidencias desde un formulario de Drupal: /issues/create

Atención, porque las dos primeras van a necesitar un parámetro que será el identificador (issue_id) de la incidencia que queremos modificar o eliminar, y que debemos especificar en el hook_menu(), que quedaría así (ojo a las partes en negrita):

/**
 * Implements hook_menu().
 *
 * Defines URLS for the list, create, edit and delete actions.
 */
function issue_control_menu() {
  $items = array();

  $items['issues/list'] = array(
    'title' => 'Issues List',
    'description' => 'Issues List from the database.',
    'page callback' => 'issue_control_list',
    'page arguments' => array(),
    'access callback' => TRUE,
  );

  $items['issues/create'] = array(
    'title' => 'Issues Form',
    'description' => 'A form to write rows into issues table.',
    'page callback' => 'drupal_get_form',
    'page arguments' => array('issue_control_form'),
    'access callback' => TRUE,
  );

  $items['issues/edit/%'] = array(
    'title' => 'Issues Form',
    'description' => 'A form to write rows into issues table.',
    'page callback' => 'drupal_get_form',
    'page arguments' => array('issue_control_form', 2),
    'access callback' => TRUE,
  );

  $items['issues/delete/%'] = array(
    'title' => 'Delete issue',
    'description' => 'Deletes an issue.',
    'page callback' => 'issue_control_perform_delete',
    'page arguments' => array(2),
    'access callback' => TRUE,
  );

  return $items;
}

Las definiciones de las URLs de modificar y eliminar llevan un símbolo % que actua de comodín, y se pasa después como parámetro a la función que definimos en 'page callback', mediante la siguiente línea de 'page arguments'. En nuestro caso estamos pasando el argumento 2, ya que el 0 sería 'issues', el 1 sería 'delete' o 'edit', y el 2 será el identificador de la incidencia que ya estamos incluyendo en la URL cuando creamos nuestra lista.

De esta forma, cuando llamamos a la url http://nuestro.drupal/issue/edit/1, el último 1 (que es el issue_id) se recibirá en nuestra función como un parámetro.

Además, en el caso de las llamadas de modificar y crear, la función que ponemos en el 'page callback' no es directamente una función declarada por nosotros, sino una llamada a drupal_get_form(), a la que pasamos el nombre de nuestra función que pintará realmente el formulario.

Acceso a datos: Las funciones básicas

Antes de empezar a desarrollar el formulario para editar y crear incidencias, vamos a empezar por la parte básica primero: las funciones de acceso a datos. Es lógico que implementemos estas funciones esenciales, ya que lo normal en aplicaciones grandes es que tengamos varias llamadas, por ejemplo, para cargar una incidencia en varias partes del código, por lo podremos reutilizalas, y favorecemos la encapsulación, el principio de responsabilidad simple, etc.

Estas son las funciones que vamos a necesitar:

Acción	Función	Descripción
Cargar	issue_control_load_issue()	Devuelve una incidencia.
Nueva	issue_control_add()	Crea una indicencia en la tabla.
Modificar	issue_control_edit()	Modifica los datos de una incidencia.
Eliminar	issue_control_delete()	Eliminar una indicencia.

Es buena práctica en Drupal que todas los nombres de funciones que declaremos se precedan con el nombre de nuestro módulo. Asi nos evitaremos sorpresas desagradables, ya que si dos funciones en distintos módulos se llaman igual, tendremos un error de PHP.

Cargar incidencia

La primera función de acceso a datos que necesitamos va a ser para obtener los datos de una incidencia de la tabla a partir de su identificador (issue_id).

function issue_control_load_issue($issue_id) {
  $issue = NULL;

  if (isset($issue_id)) {
    $issue = db_select('{issues}', 'i')
      ->fields('i')
      ->condition('issue_id', $issue_id, '=')
      ->execute()
      ->fetchAssoc();
  }

  return $issue;
}

Estamos utilzando en este caso la función db_select() de la API de Drupal para recuperar un único registro mediante la condición de que coincida el issue_id con el que recibimos por parámetro. Esta función nos devolverá un objeto de tipo SelectQuery que este caso estamos ejecutando directamente en la misma línea con execute() y recuperando el registro con fetchAssoc().

La función nos devolverá un array con los valores de los campos hemos especifiquedo en fields, en este caso todos. Para acceder mas tarde a los datos de los campos lo haremos así:

$issue = issue_control_load_issue($issue_id);
print ($issue['title']);

Crear incidencia

La siguiente función que vamos a necesitar será para dar de alta una nueva incidencia en la tabla. El código es el siguiente:

/**
 * Creates an issue.
 */
function issue_control_add($form_state) {
  global $user;

  $issue_id = db_insert('{issues}')
    ->fields(array(
      'title' => $form_state['values']['title'],
      'description' => $form_state['values']['description'],
      'uid' => $user->uid,
    ))
    ->execute();

  $message = t('New issue [@issue_id] has been created by uid [@uid].',
    array('@issue_id' => $issue_id, '@uid' => $user->uid)
  );
  watchdog('watchdog_form', $message);
  drupal_set_message($message);
}

En esta función estamos recibiendo como parámetro un array $form_state, que es que nos llega cuando se envía el formulario que construiremos mas tarde. De momento podeis ver que este $form_state obtenemos los valores de los campos para guardar el registro.

El otro dato que necesitamos a la hora de crear la incidencia es el identificador del usuario que la esta creando. Para ello usamos la variable global $user de Drupal, de la que podemos obtenemos el uid.

Aquí la parte importante es la función db_insert() de Drupal que es la encargada de guardar dicho registro. La sintaxis es muy sencilla, recibe por parámetro el nombre de la tabla y después usamos el método fields para añadir los campos y sus valores, y llamamos al execute() para lanzar la consulta.

A continuación estamos creando un mensaje con información del registro que acabamos de crear con el que vamos a hacer dos cosas:

Lo guardamos al watchdog de Drupal, para dejar un registro de cuando se creó.
Lo pasamos a drupal_set_message(), y Drupal lo mostrará en la siguiente página, para informar al usuario.

Esta función no devuelve ningún valor, aunque deberíamos añadir al menos un control de errores.

Modificar incidencia

Vamo ahora con la modificación de datos de una incidencia. En este caso también vamos a recibir por parámetro un array $form_state que vendrá del envío del formulario de edición.

function issue_control_edit($form_state) {
  global $user;

  db_update('{issues}')
    ->fields(array(
      'issue_id' => $form_state['values']['issue_id'],
      'title' => $form_state['values']['title'],
      'description' => $form_state['values']['description'],
      'uid' => $user->uid,
    ))
    ->condition('issue_id', $form_state['values']['issue_id'], '=')
    ->execute();

  $message = t('Issue [@issue_id] has been edited by uid [@uid].',
    array('@issue_id' => $form_state['values']['issue_id'], '@uid' => $user->uid)
  );
  watchdog('watchdog_form', $message);
  drupal_set_message($message);
}

Igual que en el caso de la creación del registro, usamos la variable global $user para obtener el uid del usuario que esta modificando la incidencia.

Para este caso, utlizamos la función db_update() de Drupal, y de forma similar a la creación del registro, obtenemos los valores de los campos del array $form_state, y establecemos que la condición para modificar los registros es la coincidencia por el issue_id con el que hemos recibido.

De la misma forma que en el caso anterior, componemos un mensaje que se manda al watchdog y se muestra al usuario.

Eliminar incidencia

La última función de acceso a datos es para borrar incidencias de la tabla.

function issue_control_delete($issue_id) {
  global $user;

  db_delete('{issues}')
    ->condition('issue_id', $issue_id)
    ->execute();

  $message = t('Issue [@issue_id] has been deleted by uid [@uid].',
    array('@issue_id' => $issue_id, '@uid' => $user->uid)
  );
  watchdog('watchdog_form', $message);
  drupal_set_message($message);
}

En este caso también es necesario recibir como parámetro el identificador de la incidencia para poder eliminarla utilizando db_delete() de Drupal.

Como en los casos anteriores, componemos un mensaje informativo y lo enviamos al watchdog y al usuario.

El formulario de creación y modificación

Una vez tenemos nuestra API de acceso a base de datos, solo nos queda contruir el formulario de creación y modificación de incidencias, y la llamada para eliminarlas.

Para construir el formulario vamos a utilizar la Form API de Drupal, que nos permite definir un formulario completo utilizando un array asociativo para definir los controles.

La función se llamara issue_control_form() y quedará así, atención a las partes en negrita:

function issue_control_form($form, &$form_status, $issue_id = NULL) {

  $issue = issue_control_load_issue($issue_id);

  $form['issue_id'] = array(
    '#type' => 'textfield',
    '#title' => 'Id',
    '#required' => TRUE,
    '#disabled' => TRUE,
    '#default_value' => isset($issue) ? $issue['issue_id'] : '',
  );

  $form['title'] = array(
    '#type' => 'textfield',
    '#title' => 'Title',
    '#required' => TRUE,
    '#default_value' => isset($issue) ? $issue['title'] : '',
  );

  $form['description'] = array(
    '#type' => 'textarea',
    '#title' => 'Description',
    '#default_value' => isset($issue) ? $issue['description'] : '',
  );

  if (isset($issue)) {
    $submit_message = t('Save issue');
  }
  else {
    $submit_message = t('Create issue');
  }

  $form['submit_button'] = array(
    '#type' => 'submit',
    '#value' => $submit_message,
  );

  return $form;
}

El formulario en este caso es muy sencillo, con tres campos y botón para envíar el formulario:

Identificador issue_id: Será un campo de texto sencillo (textfield), pero lo vamos a desactivar para que el usuario no pueda escribir en el.
Campo title: el título de la incidencia. Otro campo tipo textfield.
Campo description: Descripción de la incidencia. Este campo es mas largo, asi que usaremos un tipo textarea para mostrar una caja de texto grande con multiples líneas. Este tipo de campo puede configurarse también para usar un editor de texto enriquecido.

Usando Bootstrap se vería algo parecido a esto:

Lo imporante en este caso es que esta función sera utilizada por drupal_get_form(), y puede recibir un tercer parámetro que será el issue_id, en el caso de que sea llamada desde el hook_menu() para modificar.

En el caso de recibir ese parámetro, cargamos los datos de esa incidencia mediante issue_control_load_issue(), y ponemos los valores por defecto de los campos a los valores correspondientes, para que el usuario ya vea el formulario relleno con los datos y pueda modificarlos.

Dependiendo del caso, ajustaremos tambien el texto del botón de enviar el formulario, mostrando el mensaje correspondiente a cada caso: Guardar o modificar.

Ahora necesitamos la función que va a controlar que hacer cuando el usuario envía el formulario:

function issue_control_form_submit($form, &$form_state) {

  if (empty($form_state['values']['issue_id'])) {
    issue_control_add($form_state);
  }
  else {
    issue_control_edit($form_state);
  }

  drupal_goto('/issues/list');
}

Esta función simplemente comprueba el issue_id que viene al envíar el formulario (en el $form_state) está vacío, en cuyo caso se tratará de una nueva incidencia, y llamamos a nuestra función issue_control_add para crear el nuevo registro.

Si por el contrario tenemos un valor en issue_id, se tratará de una moficiación, por lo que se llama a issue_control_edit().

En ambos casos, el usuario será redirigido a la página del listado de incidencias.

Eliminando incidencias

Para este ejemplo lo haremos muy sencillo, implementando la función que se llamará desde el hook_menu:

function issue_control_perform_delete($issue_id) {
  issue_control_delete($issue_id);
  drupal_goto('/issues/list');
}

Esta función simplemente llama a nuestra función de acceso a datos issue_control_delete() y le pasa el identificador de la incidencia. Una vez eliminada, devolvemos al usuario a la lista de incidencias.

Lo suyo sería implementar algún mecanismo para obtener una confirmación del usuario antes de eliminar, para evitar errores, pero no me quiero extender mas con este ejercicio, mejor lo dejamos para otro rato. Si alguien tiene interés que me deje un comentario.

Espero que el ejemplo no haya quedado demasiado espeso y que os ayude. A modo de cierre un par de cosas que quedan en el aire:

Habria que sacar el HTML de la lista de incidencias que vimos en la primera parte a un template.
Ojo porque no hemos hablado nada de seguridad. Todas las funciones de base de datos de Drupal que estamos usando estan protegidas contra inyección de SQL, pero es una buena práctica utilizar la funcion check_plain() cada vez que vayamos a pintar información que viene de la base de datos.

Muchas gracias y saludos

Comments

Consulta abrir venta de un link de una consulta base de datos

Muy interesante y completo sus explicación sobre las base de datos, me queda una inquietud, si me podría ayudar al listar los datos de una base datos y crear un link que abra una venta nueva y pida datos para una nueva consulta.
Gracias.

tutorial

Esplendido!! me ayudado muchísimo, estoy siguiendo un tutorial sobre un libro de drupal 7 y en esta parte de entidades me había quedado clavado. Gracias a este tutorial me he quedado sin ninguna duda.Muchas gracias.

Añadir nuevo comentario

Acceso a base datos en Drupal 7

root — Sat, 11 Nov 2017 13:50:48 +0000

Acceso a base datos en Drupal 7

Sábado, Noviembre 11, 2017 - 14:50

Drupal

Database

Issues

Estamos haciendo unas sesiones de formación en el trabajo con Drupal 7, y nos ha quedado un ejercicio bastante completo que creo que merece la pena publicar por si puede ayudar a alguien mas.

La idea es mostrar cómo podemos crear un módulo en Drupal 7 que cree su propia tabla en la base de datos, y realizar operaciones sobre ella usando la API de acceso a datos de Drupal.

Para este ejemplo vamos a crear un módulo que nos permita gestionar una tabla sencilla de incidencias (Issues). Los objetivos va a ser:

Crear una nueva tabla en la base de datos de Drupal.
Listar todos los registros de la tabla
Crear nuevos registros mediante un formulario
Modificar los datos de un registro
Eliminar registros de la tabla

Voy a partir el ejercicio en dos artículos para que no me quede un ladrillo infumable, a ver si lo consigo.

Antes de empezar un par de cosas:

Estoy usando un Drupal 7 corriente y moliente. Para este ejemplo no necesitamos instalar ninguna dependencia (de módulos).
El tema de presentación que uso es Bootstrap, así que el HTML que vamos a ver usará algunas clases de Bootstrap que nos ayudará un poco con la presentación. No es realmente necesario y el HTML tendréis que adaptarlo según vuestras necesidades.
Todos los nombres de campos, tablas, etc. van a ir en inglés. Los textos de la interfaz (botones, etiquetas, etc.) también, ya que vamos a usar siempre la función t() de Drupal para traducir.

Comencemos.

Creando nuestro módulo

Para el ejemplo vamos a crear un nuevo módulo para el control de nuestra tabla de incidencias, que llamaremos issue_control. Lo creamos en el directorio estándar:

sites/all/modules/custom/issue_control

Tan sólo vamos a necesitar tres archivos:

issue_control.info: Archivo de control del módulo.
issue_control.module: Aquí tendremos nuestro código PHP.
issue_control.install: Lo usaremos para definir la tabla en la base de datos.

Para empezar, será suficiente con completar el archivo info, con algo parecido a esto:

name = Issues control
project = "issue_control"
description = "Store information into a database table"
package = Custom
core = 7.x
version = "7.x-0.0-rc1"

De momento, con esto nos vale para comenzar. Ojo, es mejor no instalar o activar el módulo todavía, hasta que tengamos la definición del esquema de base de datos. Vamos a ello, a ver como creamos nuestra tabla.

Hook Schema: Creando nuestra tabla

Perfecto, ya tenemos nuestro módulo. Ahora la idea es que al instalar el módulo, este nos cree automáticamente la tabla que necesitamos en la base de datos. Para ello vamos a usar el hook_schema(), que vamos a implementar en el archivo issue_control.install que acabamos de crear.

Pero primero vamos a ver que campos necesitamos en nuestra tabla. Hagamos algo sencillo:

Campo	Tipo	Nulo	Descripción
issue_id	Int	NO	El identificador de la incidencia. Debería ser una secuencia o un autoincrement. No puede ser nulo, ya que lo vamos a usar como identificador y primary key. En Drupal usaremos el tipo serial, que nos permite hacer justamente eso y no tener que preocuparnos de rellenarlo nosotros.
title	String (255)	NO	Título de la incidencia. Una cadena de caracteres no muy larga. No queremos que se quede vacío. En Drupal usaremos el tipo varchar.
description	String (Largo)		Este será el campo para guardar el contenido de la incidencia. Queremos que sea una text area donde el usuario pueda meter mucho texto. Para esto en Drupal tenemos el tipo text.
uid	Int	NO	Vamos a incluir el id del usuario (uid) que crea o modifica la incidencia, para que nos dé un poco de juego el ejercicio. Este sera un campo numérico sencillo de tipo int en nuestro Drupal.

Bien, ahora que tenemos mas o menos claro los campos que queremos, vamos a crear nuestro hook_schema. Este hook debe ser implementado en el archivo .install del módulo, y nos va a permitir declarar una o varias tablas que se crearán cuando se instale el módulo (ojo: instalación, no activación) y se eliminarán automáticamente cuando se desinstale (ojo otra vez: desinstalar, no deshabilitar).

Vamos a ver el código:

<?php

/**
 * Implements hook_schema().
 */
function issue_control_schema() {
  $schema['issues'] = array(
    'description' => 'Table for storing issues',
    'fields' => array(
      'issue_id' => array(
        'type' => 'serial',
        'unsigned' => TRUE,
        'not null' => TRUE,
        'description' => 'Issue ID',
      ),
      'title' => array(
        'type' => 'varchar',
        'length' => 255,
        'not null' => TRUE,
        'default' => '',
        'description' => 'Issue title',
      ),
      'description' => array(
        'type' => 'text',
        'size' => 'normal',
        'description' => 'Issue description',
      ),
      'uid' => array(
        'type' => 'int',
        'unsigned' => TRUE,
        'not null' => TRUE,
        'default' => 0,
        'description' => 'User uid for the issue',
      ),

    ),
    'primary key' => array('issue_id'),
    'indexes' => array(
      'issueid' => array('issue_id'),
    ),
  );

  return $schema;
}

La referencia del Schema API de Drupal tiene bastante miga, y daría para varios artículos, pero no es el objetivo de este post. Recomiendo darle un buen repaso a la documentación, aunque no he podido encontrarla en castellano.

Es importante tener en cuenta que si tenéis errores en este fichero o en este hook, lo más probable es que pete al instalar el módulo y no cree nada. Para que Drupal vuelva a ejecutar el hook_schema después de una prueba fallida, teneis que desinstalar el módulo por completo y volver a instalar. Podeis usar drush pmu issue_control, o bien utilizar el módulo Devel, que tiene una opción para reinstalar módulos muy útil para esto, hasta que consigáis que funcione correctamente la creación de la tabla.

Listado de registros de la tabla

Lo primero que vamos a hacer es preparar una página para mostrar el listado de las incidencias guardadas en la tabla. Logicamente, al principio estará vacía si acabamos de instalar el módulo. Podemos crear algunos registros a mano, o bien utilizando una herramienta como phpMyAdmin. Una ejemplo sencillo para tener algunos datos de prueba podría ser usando Drush:

drush sql-cli

insert into issues (title, description, uid) values ('Un titulo', 'Description de pruebas', 1);

Para hacer nuestro listado vamos a utilizar dos funciones en nuestro archivo .module:

Un hook_menu para definir la URL que usaremos para la lista, y la función a llamar para pintarla.
Una función nuestra que devolverá el listado de incidencias en formato HTML.

Primero, vamos a crear un hook_menu, y definiremos la URL /issues/list para nuestro listado de incidencias. De esta forma, cuando carguemos la URL http://misitio.drupal/issues/list, obtendremos la lista de incidencias.

En nuestro archivo .module, declaramos el hook_menu:

/**
 * Implements hook_menu().
 *
 */
function issue_control_menu() {
  $items = array();

  $items['issues/list'] = array(
    'title' => 'Issues List',
    'description' => 'Issues list from the database.',
    'page callback' => 'issue_control_list',
    'page arguments' => array(),
    'access callback' => TRUE,
  );

   return $items;
}

Con este hook definimos la URL y especificamos que al cargar dicha URL, se ejecutará la función issue_control_list() para pintar los resultados.

Después implementamos esa función para listar:

/**
 * Shows a list with all issues in the database table.
 */
function issue_control_list() {

  $content = '<table class="table table-hover table-striped">';
  $content .= '<tr>';
  $content .= '<th>' . t('Issue Id') . '</th>';
  $content .= '<th>' . t('Title') . '</th>';
  $content .= '<th>' . t('Description') . '</th>';
  $content .= '<th>' . t('Username') . '</th>';
  $content .= '<th>' . t('Actions') . '</th>';
  $content .= '</tr>';

  $results = db_query('SELECT * FROM {issues}');
  foreach ($results as $row) {
    $user = user_load($row->uid);

    $content .= '<tr>';
    $content .= '<td>' . $row->issue_id . '</td>';
    $content .= '<td>' . $row->title . '</td>';
    $content .= '<td>' . $row->description . '</td>';
    $content .= '<td>' . (!empty($user->name) ? $user->name : t('Anonymous')) . '</td>';
    $content .= '<td class="btn-toolbar">';
    $content .= '<a class="btn btn-xs btn-primary" href="' . url('/issues/edit/' . $row->issue_id) . '">' . t('Edit') . '</a>';
    $content .= '<a class="btn btn-xs btn-danger" href="' . url('/issues/delete/' . $row->issue_id) . '">' . t('Delete') . '</a>';
    $content .= '</td>';
    $content .= '</tr>';
  }

  $content .= '</table>';
  $content .= '<a class="btn btn-success" href="' . url('/issues/create') . '">' . t('Add an issue') . '</a>';

  return $content;
}

Con este código estamos obteniendo todos los registros de la tabla issues y pintando una tabla HTML para mostrar los resultados. Esta función tiene varias partes interesantes.

Se utiliza una variable $content para ir guardando el HTML que vamos construyendo.
Primero creamos las cabeceras de la tabla con los nombres de los campos.
Después, se lanza la consulta a la base de datos para pedir todos los registros de la tabla issues.
A continuación se utiliza un bucle para pintar cada uno de los registros. Para cada registro cargaremos el usuario de Drupal correspondiente al uid que venga en la issue, y pintamos su nombre.
Las clases CSS que estoy utilizando son para Bootstrap, por ejemplo, los table y table-striped nos proporcionarán una tabla más pintona, o los btn y btn-primary para los botones de acción.

Obteniendo los datos

Vamos a ver un poco mas en detalle cómo estamos obteniendo los registros de la base de datos. En este caso como es una query muy sencilla, usaremos la función db_query de Drupal:

$results = db_query('SELECT * FROM {issues}');

Esta llamada nos devuelve el resultado de la query como un array en la variable $results. Un detalle importante es utilizar el nombre de la tabla entre llaves, ya que Drupal lo reemplazará por la tabla correcta si nuestro sitio usa un prefijo (prefix) para la base de datos.

Este array tendrá un objeto de tipo stdClass por cada registro de la base de datos que devuelva la consulta, y en cada uno de estos objetos podremos acceder a los campos de la tabla como si fuesen propiedades, por ejemplo $row->title, nos devolverá el título.

De esta forma, para leer y pintar los registros usaremos un bucle, e iremos recogiendo los valores de cada campo que queremos mostrar:

foreach ($results as $row) {
  $user = user_load($row->uid); // Aquí cargamos el usuario correspondiente por su uid.
  
  $content .= '<tr>';
  $content .= '<td>' . $row->issue_id . '</td>'; // Pintamos el campo issue_id.
  ... 
}

No debemos usar db_query para realizar operaciones de insert, update o delete, y si necesitamos realizar operaciones con la query antes de ejecutarla, es mejor usar la función db_select que veremos más adelante.

Resultados

Si todo ha ido bien tendremos algo parecido a este ejemplo que se ve bastante resultón gracias a Bootstrap:

Como podéis ver, estamos ya pintando los botones de acción para cada registro: Edit y Delete, que son enlaces a otras páginas que aún no existen, y después de la tabla tenemos otro botón para crear una incidencia nueva. Estos enlaces serán:

Un enlace /issues/edit/[issue_id] para modificar los datos de una incidencia.
Otro a /issues/delete/[issue_id] para eliminar incidencias de la tabla.
Por último, /issues/create para dar de alta incidencias desde un formulario de Drupal.

Estas tres acciones las veremos en el próximo artículo, en el que os dejaré un enlace para descargar todo el código del ejemplo completo.

Como pequeña puntualización, esta función para pintar la lista tiene demasiado código HTML. Lo correcto sería utilizar una plantilla o template para pintar la lista, de forma que todo el HTML estaría dentro del template. Hay mil ejemplos en internet para utilizar templates en nuestros módulos con Drupal 7, pero aún así pienso escribir otro artículo después de estos para mostrar cómo hacerlo en condiciones con este ejemplo.

Muchas gracias y hasta pronto.

La segunda parte de este artículo esta aquí.

Añadir nuevo comentario

Error ERROR 1071 (42000) al importar una base de datos Drupal

root — Sat, 18 Mar 2017 17:28:08 +0000

Error ERROR 1071 (42000) al importar una base de datos Drupal

Sábado, Marzo 18, 2017 - 18:28

Tratando de importar una copia de base de datos que había creado con drush sql-dump en otro servidor, me he encontrado con este error de MySQL:

ERROR 1071 (42000) at line 25: Specified key was too long; max key length is 767 bytes

El comando que estaba usando era bastante normal:

drush sql-cli <  ../backup.sql

Después de intentar varias opciones, también he llegado a ver este otro error:

ERROR 1709 (HY000) at line 25: Index column size too large. The maximum column size is 767 bytes.

La versión de MySQL que estaba usando es 5.6.30-1, como podéis ver aquí:

dpkg -l | grep mysql-server
ii  mysql-server                                  5.6.30-1                               all          MySQL database server (metapackage depending on the latest
version)
ii  mysql-server-5.6                              5.6.30-1                               amd64        MySQL database server binaries and system database setup
ii  mysql-server-core-5.6                         5.6.30-1                               amd64        MySQL database server binaries

El problema venia de la configuración de INNODB en mi servidor, y la solución es bastante sencilla, basta con editar el fichero de configuracion de MySQL (como root o usando sudo), que en Debian está en:

vi /etc/mysql/my.cnf

Si no teneis ese fichero puede que este aquí:

vi /etc/mysql/mysql.conf.d/mysqld.cnf

Tenemos que incluir las siguientes líneas de configuración en la sección de [mysqld]:

innodb_file_format = true
innodb_file_per_table=true
innodb_file_format=barracuda

Después reiniciamos el servidor y listo:

service mysql restart

Ahora si intentamos importar la base de datos de nuevo no deberíamos tener problemas.

EDIT:

Si no podemos tocar la configuración del servidor, podemos ejecutar esto directamente en mysql antes de ejecutar nuestra query:

SET @@global.innodb_large_prefix = 1;

Referencias:

https://dev.mysql.com/doc/refman/5.6/en/innodb-parameters.html#sysvar_innodb_large_prefix

Comments

gracias

Gracias por este articulo, me estaba volviendo loco con esto