One place for hosting & domains

      datos

      Información sobre las bases de datos relacionales


      Introducción

      Los sistemas de administración de bases de datos (DBMS) son programas que permiten a los usuarios interactuar con una base de datos. Les permiten controlar el acceso a una base de datos, escribir datos, ejecutar consultas y realizar otras tareas relacionadas con la administración de bases de datos.

      Sin embargo, para realizar cualquiera de estas tareas, los DBMS deben tener algún tipo de modelo subyacente que defina la organización de los datos. El modelo relacional es un enfoque para la organización de datos que se ha utilizado ampliamente en programas de software de bases de datos desde su concepción a fines de la década de 1960; a tal grado que, a la fecha de redacción de este artículo, cuatro de los cinco DBMS más populares son relacionales.

      Este artículo conceptual describe la historia del modelo relacional, la manera en que se organizan los datos en las bases de datos relacionales y cómo se utilizan hoy en día.

      Historia del modelo relacional

      Las bases de datos son conjuntos de información, o datos, modelados de forma lógica. Cualquier recopilación de datos es una base de datos, independientemente de cómo o dónde se almacene. Incluso un gabinete de archivos con información sobre nómina es una base de datos, al igual que una pila de formularios de pacientes hospitalizados o la recopilación de información sobre clientes de una empresa repartida en varias ubicaciones. Antes de que almacenar y administrar datos con computadoras se convirtiera en una práctica común, las bases de datos físicas como estas eran lo único con lo que contaban las organizaciones gubernamentales y empresariales que necesitaban almacenar información.

      A mediados del siglo XX, los desarrollos en las ciencias de la computación dieron lugar a máquinas con mayor capacidad de procesamiento y almacenamiento, tanto local como externo. Estos avances hicieron que los especialistas en ciencias de la computación comenzaran a reconocer el potencial que tenían estas máquinas para almacenar y administrar cantidades de datos cada vez más grandes.

      Sin embargo, no había teorías sobre cómo las computadoras podían organizar datos de manera significativa y lógica. Una cosa es almacenar datos no ordenados en una máquina, pero es mucho más complicado diseñar sistemas que permitan agregar, recuperar, clasificar y administrar esos datos de forma sistemática y práctica. La necesidad de contar con un marco de trabajo lógico para almacenar y organizar datos dio lugar a varias propuestas sobre cómo utilizar las computadoras para administrar datos.

      Uno de los primeros modelos de bases de datos fue el modelo jerárquico, en el que los datos se organizan con una estructura de árbol similar a la de los sistemas de archivos modernos. El siguiente ejemplo muestra el aspecto que podría tener el diseño de una parte de una base de datos jerárquica utilizada para categorizar animales:

      Ejemplo de base de datos jerárquica: categorización de animales

      El modelo jerárquico se implementó ampliamente en los primeros sistemas de administración de bases de datos, pero resultaba poco flexible. En este modelo, a pesar de que los registros individuales pueden tener varios “elementos secundarios”, cada uno puede tener un solo “elemento primario” en la jerarquía. Es por eso que estas primeras bases de datos jerárquicas se limitaban a representar relaciones “uno a uno” y “uno a varios”. Esta carencia de relaciones “varios a varios” podía provocar problemas al trabajar con puntos de datos que se deseaba asociar a más de un elemento primario.

      A fines de los años 60, Edgar F. Codd, un especialista en ciencias de la computación que trabajaba en IBM, diseñó el modelo relacional de administración de bases de datos. El modelo relacional de Codd permitía que los registros individuales se relacionaran con más de una tabla y, de esta manera, posibilitaba las relaciones “varios a varios” entre los puntos de datos además de las relaciones “uno a varios”. Esto proporcionó más flexibilidad que los demás modelos existentes a la hora de diseñar estructuras de base de datos y permitió que los sistemas de gestión de bases de datos relacionales (RDBMS) pudieran satisfacer una gama mucho más amplia de necesidades empresariales.

      Codd propuso un lenguaje para la administración de datos relacionales, conocido como Alfa, que influyó en el desarrollo de los lenguajes de bases de datos posteriores. Dos colegas de Codd en IBM, Donald Chamberlin y Raymond Boyce, crearon un lenguaje similar inspirado en Alpha. Lo llamaron SEQUEL, abreviatura de Structured English Query Language (Lenguaje de consulta estructurado en inglés), pero debido a una marca comercial existente, lo abreviaron a SQL (conocido formalmente como* Lenguaje de consulta estructurado*).

      Debido a las limitaciones de hardware, las primeras bases de datos relacionales eran prohibitivamente lentas y el uso de la tecnología tardó un tiempo en generalizarse. Pero a mediados de los años ochenta, el modelo relacional de Codd se había implementado en varios productos comerciales de administración de bases de datos, tanto de IBM como de sus competidores. Estos proveedores también siguieron el liderazgo de IBM al desarrollar e implementar sus propios dialectos de SQL. Para 1987, tanto el Instituto Nacional Estadounidense de Estándares (American National Standards Institute) como la Organización Internacional de Normalización (International Organization for Standardization) habían ratificado y publicado normas para SQL, lo que consolidó su estado como el lenguaje aceptado para la administración de RDBMS.

      Gracias al uso extendido del modelo relacional en varias industrias, se lo comenzó a reconocer como el modelo estándar para la administración de datos. Incluso con el surgimiento de varias bases de datos NoSQL en los últimos años, las bases de datos relacionales siguen siendo las herramientas predominantes para almacenar y organizar datos.

      Cómo organizan los datos las bases de datos relacionales

      Ahora que tiene una idea general de la historia del modelo relacional, vamos a analizar en detalle cómo organiza los datos.

      Los elementos más fundamentales del modelo relacional son las relaciones, que los usuarios y los RDBMS modernos reconocen como tablas. Una relación es un conjunto de tuplas, o filas de una tabla, en el que cada una de ellas comparte un conjunto de atributos o columnas:

      Diagrama de ejemplo de la asociación entre las relaciones, las tuplas y los atributos

      Una columna es la estructura de organización más pequeña de una base de datos relacional y representa las distintas facetas que definen los registros en la tabla. De ahí proviene su nombre más formal: atributos. Se puede pensar que cada tupla es como una instancia única de cualquier tipo de personas, objetos, eventos o asociaciones que contenga la tabla.  Estas instancias pueden ser desde empleados de una empresa y ventas de un negocio en línea hasta resultados de pruebas de laboratorio. Por ejemplo, en una tabla que contiene registros de los maestros de una escuela, las tuplas pueden tener atributos como name, subjects, start_date, etc.

      Al crear una columna, especificamos un* tipo de datos *que determina el tipo de entradas que se permiten en esa columna. Los sistemas de administración de bases de datos relacionales (RDBMS) suelen implementar sus propios tipos de datos únicos, que pueden no ser directamente intercambiables con tipos de datos similares de otros sistemas. Algunos tipos de datos frecuentes son fechas, cadenas, enteros y booleanos.

      En el modelo relacional, cada tabla contiene, por lo menos, una columna que puede utilizarse para identificar de forma única cada fila, lo que se denomina clave primaria. Esto es importante, dado que significa que los usuarios no necesitan saber dónde se almacenan físicamente los datos en una máquina; en su lugar, sus DBMS pueden realizar un seguimiento de cada registro y devolverlo según corresponda. A su vez, significa que los registros no tienen un orden lógico definido y que los usuarios tienen la capacidad de devolver sus datos en cualquier orden y a través de los filtros que deseen.

      Si tiene dos tablas que desea asociar, una manera de hacerlo es con una clave externa. Una clave externa es, básicamente, una copia de la clave primaria de una tabla (la tabla “primaria”) insertada en una columna de otra tabla (la “secundaria”). El siguiente ejemplo destaca la relación entre dos tablas: una se utiliza para registrar información sobre los empleados de una empresa y la otra, para realizar un seguimiento de las ventas de la empresa. En este ejemplo, la clave primaria de la tabla EMPLOYEES se utiliza como clave externa de la tabla SALES:

      Diagrama de ejemplo de cómo la clave primaria de la tabla EMPLOYEE actúa como la clave externa de la tabla SALES

      Si intenta agregar un registro a la tabla secundaria y el valor ingresado en la columna de la clave externa no existe en la clave primaria de la tabla primaria, la instrucción de inserción no será válida. Esto ayuda a mantener la integridad del nivel de las relaciones, dado que las filas de ambas tablas siempre se relacionarán correctamente.

      Los elementos estructurales del modelo relacional ayudan a mantener los datos almacenados de forma organizada, pero el almacenamiento de datos solo es útil si se pueden recuperar. Para obtener información de un RDBMS, puede emitir una consulta o una solicitud estructurada de un conjunto de información. Como se mencionó anteriormente, la mayoría de las bases de datos relacionales utilizan SQL para administrar y consultar datos. SQL permite filtrar y manipular los resultados de las consultas con una variedad de cláusulas, predicados y expresiones, lo que, a su vez, permite controlar correctamente qué datos se mostrarán en el conjunto de resultados.

      Ventajas y limitaciones de las bases de datos relacionales

      Teniendo en cuenta la estructura organizativa subyacente de las bases de datos relacionales, consideremos algunas de sus ventajas y desventajas.

      Hoy en día, tanto SQL como las bases de datos que lo implementan se desvían del modelo relacional de Codd de diversas maneras. Por ejemplo, el modelo de Codd determina que cada fila de una tabla debe ser única, mientras que, por cuestiones de practicidad, la mayoría de las bases de datos relacionales modernas permiten la duplicación de filas. Algunas personas no consideran que las bases de datos SQL sean verdaderas bases de datos relacionales a menos que cumplan con las especificaciones de Codd del modelo relacional. Sin embargo, en términos prácticos, es probable que cualquier DBMS que utilice SQL y, por lo menos, se adhiera en cierta medida al modelo relacional se denomine “sistema de administración de bases de datos relacionales”.

      A pesar de que las bases de datos relacionales ganaron popularidad rápidamente, algunas de las deficiencias del modelo relacional comenzaron a hacerse evidentes a medida que los datos se volvieron más valiosos y las empresas comenzaron a almacenar más de ellos. Entre otras cosas, puede ser difícil escalar una base de datos relacional de forma horizontal.  Los términos escalado horizontal o escala horizontal se refieren a la práctica de agregar más máquinas a una pila existente para extender la carga y permitir un mayor tráfico y un procesamiento más rápido. Se suele contrastar con el escalado vertical, que implica la actualización del hardware de un servidor existente, generalmente, añadiendo más RAM o CPU.

      El motivo por el cual es difícil escalar una base de datos relacional de forma horizontal está relacionado con el hecho de que el modelo relacional se diseñó para garantizar coherencia, lo que significa que los clientes que realizan consultas en la misma base de datos siempre obtendrán los mismos datos. Al querer escalar una base de datos relacional de forma horizontal en varias máquinas, resulta difícil asegurar la coherencia, dado que los clientes pueden escribir datos en un nodo pero no en otros.  Es probable que haya un retraso entre la escritura inicial y el momento en que se actualicen los demás nodos para reflejar los cambios, lo que daría lugar a inconsistencias entre ellos.

      Otra limitación que presentan los RDBMS es que el modelo relacional se diseñó para administrar datos estructurados o alineados con un tipo de datos predeterminado o, por lo menos, organizado de una manera predeterminada para que se puedan ordenar o buscar de forma más sencilla. Sin embargo, con la difusión de los equipos informáticos personales y el auge de Internet a principios de la década de 1990, los datos no estructurados, como los mensajes de correo electrónico, las fotos, los videos, etc., se volvieron más comunes.

      Nada de esto significa que las bases de datos relacionales no sean útiles. Al contrario, después de más de 40 años, el modelo relacional sigue siendo el marco dominante para la administración de datos. Su prevalencia y longevidad indican que las bases de datos relacionales son una tecnología madura, lo que constituye una de sus principales ventajas. Hay muchas aplicaciones diseñadas para trabajar con el modelo relacional, así como muchos administradores de bases de datos profesionales expertos en bases de datos relacionales. También hay una amplia variedad de recursos disponibles en formato impreso y digital para quienes desean comenzar a utilizar bases de datos relacionales.

      Otra ventaja de las bases de datos relacionales es que casi todos los RDBMS admiten transacciones. Las transacciones constan de una o más instrucciones SQL individuales que se ejecutan en secuencia como una unidad de trabajo única. Las transacciones tienen un enfoque de todo o nada, lo que significa que todas las instrucciones SQL de una transacción deben ser válidas; de lo contrario, falla en su totalidad. Esto es muy útil para garantizar la integridad de los datos al realizar cambios en varias filas o tablas.

      Por último, las bases de datos relacionales son sumamente flexibles. Se han utilizado para crear una amplia variedad de aplicaciones distintas y siguen funcionando de forma eficiente incluso con grandes cantidades de datos. SQL también es sumamente potente y permite agregar y cambiar datos sobre la marcha, así como alterar la estructura de los esquemas y las tablas de las bases de datos sin afectar a los datos existentes.

      Conclusión

      Gracias a su flexibilidad y diseño para la integridad de los datos, más de cincuenta años después de su concepción inicial, las bases de datos relacionales siguen siendo la principal forma de administrar y almacenar datos.  A pesar del surgimiento de diversas bases de datos NoSQL en los últimos años, la comprensión del modelo relacional y la manera de trabajar con RDBMS es fundamental para cualquier persona que desee crear aplicaciones que aprovechen el poder de los datos.

      Para obtener más información sobre RDBMS populares de código abierto, le recomendamos consultar nuestra comparación de diversas bases de datos relacionales SQL de código abierto. Si desea obtener más información sobre las bases de datos en general, le recomendamos consultar nuestra biblioteca completa de contenidos relacionados con bases de datos.



      Source link

      Cómo utilizar el tipo de datos BLOB de MySQL para almacenar imágenes con PHP en Ubuntu 18.04


      El autor seleccionó Girls Who Code para recibir una donación como parte del programa Write for DOnations.

      Introducción

      El tipo de datos de gran objeto binario (BLOB) es un tipo de datos de MySQL que puede almacenar datos binarios como los de archivos de imagen, multimedia y PDF.

      Al crear aplicaciones que requieren una base de datos estrechamente acoplada donde las imágenes deben estar sincronizadas con los datos relacionados (por ejemplo, un portal de empleados, una base de datos de estudiantes o una aplicación financiera), puede resultarle conveniente almacenar imágenes como las de fotos y firmas de pasaportes de estudiantes en una base de datos de MySQL junto con otra información relacionada.

      Aquí es donde entra el tipo de datos BLOB de MySQL. Este enfoque de programación elimina la necesidad de crear un sistema de archivos independiente para almacenar imágenes. El esquema también centraliza la base de datos, haciéndola más portátil y segura porque los datos están aislados del sistema de archivos. Crear copias de seguridad también es más sencillo, ya que que puede crear un solo archivo MySQL dump que contenga todos sus datos.

      La recuperación de datos es más rápida y, al crear registros, podrá estar seguro de que las reglas de validación de datos y la integridad referencial se preserven, en especial al utilizar transacciones en MySQL.

      En este tutorial, utilizará el tipo de datos BLOB de MySQL para almacenar imágenes con PHP en Ubuntu 18.04.

      Requisitos previos

      Para completar esta guía, necesitará lo siguiente:

      Paso 1: Crear una base de datos

      Comenzará creando una base de datos de ejemplo para su proyecto. Para hacer esto, aplique SSH a su servidor y luego ejecute el siguiente comando para iniciar sesión en su servidor MySQL como root:

      Ingrese la contraseña root de su base de datos de MySQL y presione INTRO para continuar.

      Luego, ejecute el siguiente comando para crear una base de datos. En este tutorial, lo llamaremos test_company:

      • CREATE DATABASE test_company;

      Una vez que cree la base de datos, verá el siguiente resultado:

      Output

      Query OK, 1 row affected (0.01 sec)

      Luego, cree una cuenta test_user en el servidor de MySQL y recuerde reemplazar PASSWORD por una contraseña segura:

      • CREATE USER 'test_user'@'localhost' IDENTIFIED BY 'PASSWORD';

      Verá el siguiente resultado:

      Output

      Query OK, 0 rows affected (0.01 sec)

      Para otorgar a test_user privilegios completos respecto de la base de datos test_company, ejecute lo siguiente:

      • GRANT ALL PRIVILEGES ON test_company.* TO 'test_user'@'localhost';

      Asegúrese de obtener el siguiente resultado:

      Output

      Query OK, 0 rows affected (0.01 sec)

      Por último, elimine la tabla de privilegios para que MySQL vuelva a cargar los permisos:

      Asegúrese de ver el siguiente resultado:

      Output

      Query OK, 0 rows affected (0.01 sec)

      Ahora que la base de datos test_company y test_user están listos, continúe creando una tabla products para almacenar productos de ejemplo. Más adelante, utilizará esta tabla para insertar y obtener registros a fin de demostrar cómo funciona BLOB de MySQL.

      Cierre sesión en el servidor de MySQL:

      Luego, vuelva a iniciar sesión con las credenciales de test_user que creó:

      Cuando se le solicite, ingrese la contraseña de test_user y presione ENTER para continuar. Luego, posiciónese en la base de datos test_company escribiendo lo siguiente:

      Una vez que seleccione la base de datos test_company, MySQL mostrará lo siguiente:

      Output

      Database changed

      Luego, cree una tabla products ejecutando lo siguiente:

      • CREATE TABLE `products` (product_id BIGINT PRIMARY KEY AUTO_INCREMENT, product_name VARCHAR(50), price DOUBLE, product_image BLOB) ENGINE = InnoDB;

      Con este comando se crea una tabla llamada products. La tabla tiene cuatro columnas:

      • product_id: esta columna utiliza un tipo de datos BIGINT para admitir una gran lista de productos hasta un máximo de 2⁶³-1 artículos. Se marca la columna como PRIMARY KEY para identificar productos de manera exclusiva. Para que MySQL administre la generación de nuevos identificadores para columnas insertadas, utilizó la palabra clave AUTO_INCREMENT.

      • product_name: esta columna contiene los nombres de los productos. Se utiliza el tipo de datos VARCHAR, ya que este campo generalmente administra alfanuméricos de hasta un máximo de 50 caracteres; el límite de 50 es solo un valor hipotético utilizado para de este tutorial.

      • price: para fines demostrativos, su tabla products contiene la columna price que permite almacenar el precio minorista de los productos. Dado que algunos productos pueden tener valores flotantes (por ejemplo 23.69, 45.36, 102.99), se utiliza el tipo de datos DOUBLE.

      • product_image: en esta columna se utiliza el tipo de datos BLOB para almacenar los datos binarios reales de las imágenes de los productos.

      Se utiliza el ENGINE de almacenamiento InnoDB para que la tabla admita una amplia gama de funciones, incluso transacciones de MySQL. Después de ejecutar esto para crear la tabla products, verá el siguiente resultado:

      Output

      Query OK, 0 rows affected (0.03 sec)

      Cierre la sesión de su servidor de MySQL:

      Verá el siguiente resultado:

      Output

      Bye

      La tabla products ahora está lista para almacenar algunos registros, incluidas las imágenes de los productos y, en el siguiente paso, la completará con algunos productos.

      Paso 2: Crear secuencias de comandos PHP para conectar y completar la base de datos

      En este paso, creará una secuencia de comandos PHP que se conectará a la base de datos MySQL que creó en el paso 1. La secuencia de comandos preparará tres productos de ejemplo y los insertará en la tabla products.

      Para crear el código PHP, abra un nuevo archivo con su editor de texto:

      • sudo nano /var/www/html/config.php

      Luego, ingrese la siguiente información en el archivo y reemplace PASSWORD por la contraseña test_user que creó en el paso 1:

      /var/www/html/config.php

      <?php
      
      define('DB_NAME', 'test_company');
      define('DB_USER', 'test_user');
      define('DB_PASSWORD', 'PASSWORD');
      define('DB_HOST', 'localhost');
      
      $pdo = new PDO("mysql:host=" . DB_HOST . "; dbname=" . DB_NAME, DB_USER, DB_PASSWORD);
      $pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
      $pdo->setAttribute(PDO::ATTR_EMULATE_PREPARES, false);
      
      

      Guarde y cierre el archivo.

      En este archivo, utilizó cuatro constantes PHP para conectarse a la base de datos MySQL que creó en el paso 1:

      • DB_NAME : esta constante contiene el nombre de la base de datos test_company.

      • DB_USER : esta variable contiene el nombre de usuario test_user.

      • DB_PASSWORD : esta constante almacena la PASSWORD de MySQL de la cuenta test_user.

      • DB_HOST: esto representa el servidor en el que se ubica la base de datos. En este caso, utilizará el servidor localhost.

      Con la siguiente línea de su archivo se inicia un objeto de datos de PHP (PDO) y se conecta a la base de datos MySQL:

      ...
      $pdo = new PDO("mysql:host=" . DB_HOST . "; dbname=" . DB_NAME, DB_USER, DB_PASSWORD);
      ...
      

      Cerca del final del archivo, configuró algunos atributos PDO:

      • ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION: este atributo indica a PDO que inicie una excepción que se puede registrar para depuración.
      • ATTR_EMULATE_PREPARES, false: esta opción aumenta la seguridad al indicar al motor de la base de datos MySQL que realice la preparación en lugar de PDO.

      Incluirá el archivo /var/www/html/config.php en dos secuencias de comandos PHP que creará luego para insertar y recuperar registros respectivamente.

      Primero, cree la secuencia de comandos PHP /var/www/html/insert_products.php para insertar registros en la tabla de productos:

      • sudo nano /var/www/html/insert_products.php

      Luego, añada la siguiente información al archivo /var/www/html/insert_products.php:

      /var/www/html/insert_products.php

      <?php
      
      require_once 'config.php';
      
      $products = [];
      
      $products[] = [
                    'product_name' => 'VIRTUAL SERVERS',
                    'price' => 5,
                    'product_image' => file_get_contents("https://i.imgur.com/VEIKbp0.png")
                    ];
      
      $products[] = [
                    'product_name' => 'MANAGED KUBERNETES',
                    'price' => 30,
                    'product_image' => file_get_contents("https://i.imgur.com/cCc9Gw9.png")
                    ];
      
      $products[] = [
                    'product_name' => 'MySQL DATABASES',
                    'price' => 15,
                    'product_image' => file_get_contents("https://i.imgur.com/UYcHkKD.png" )
                    ];
      
      $sql = "INSERT INTO products(product_name, price, product_image) VALUES (:product_name, :price, :product_image)";
      
      foreach ($products as $product) {
          $stmt = $pdo->prepare($sql);
          $stmt->execute($product);
      }
      
      echo "Records inserted successfully";
      

      Guarde y cierre el archivo.

      En el archivo, incluyó el archivo config.php en la parte superior. Este es el primer archivo que creó para definir las variables de la base de datos y conectarse a la base de datos. El archivo también inicia un objeto PDO y lo almacena en una variable $pdo.

      Luego, creó una matriz de datos de los productos que se insertarán en la base de datos. Aparte de product_name y price, que se preparan como cadenas y valores numéricos respectivamente, la secuencia de comandos utiliza la función file_get_contents integrada de PHP para leer imágenes de una fuente externa y pasarlas como cadenas a la columna product_image.

      Luego, preparó una instrucción SQL y utilizó la instrucción foreach{...} de PHP para insertar cada producto en la base de datos.

      Para ejecutar el archivo /var/www/html/insert_products.php, realice la ejecución en la ventana de su navegador utilizando la siguiente URL. Recuerde reemplazar your-server-IP por la dirección IP pública de su servidor:

      http://your-server-IP/insert_products.php
      

      Después de ejecutar el archivo, verá un mensaje de éxito en su navegador confirmando que los registros se insertaron en la base de datos.

      Mensaje de éxito que indica que los registros se insertaron en la base de datos

      Insertó con éxito tres registros que contienen imágenes de productos en la tabla products. En el siguiente paso, creará una secuencia de comandos PHP para obtener estos registros y mostrarlos en su navegador.

      Paso 3: Mostrar la información de los productos de la base de datos MySQL

      Con la información e imágenes de los productos en la base de datos, ahora debe codificar otra secuencia de comandos PHP que consulta y muestra la información de los productos en una tabla HTML en su navegador.

      Para crear el archivo, escriba lo siguiente:

      • sudo nano /var/www/html/display_products.php

      Luego, ingrese la siguiente información en el archivo:

      /var/www/html/display_products.php

      <html>
        <title>Using BLOB and MySQL</title>
        <body>
      
        <?php
      
        require_once 'config.php';
      
        $sql = "SELECT * FROM products";
        $stmt = $pdo->prepare($sql);
        $stmt->execute();
        ?>
      
        <table border="1" align = 'center'> <caption>Products Database</caption>
          <tr>
            <th>Product Id</th>
            <th>Product Name</th>
            <th>Price</th>
            <th>Product Image</th>
          </tr>
      
        <?php
        while ($row = $stmt->fetch(PDO::FETCH_ASSOC)) {
            echo '<tr>';
            echo '<td>' . $row['product_id'] . '</td>';
            echo '<td>' . $row['product_name'] . '</td>';
            echo '<td>' . $row['price'] . '</td>';
            echo '<td>' .
            '<img src = "data:image/png;base64,' . base64_encode($row['product_image']) . '" width = "50px" height = "50px"/>'
            . '</td>';
            echo '</tr>';
        }
        ?>
      
        </table>
        </body>
      </html>
      

      Guarde los cambios del archivo y ciérrelo.

      Aquí, nuevamente incluyó el archivo config.php para establecer conexión con la base de datos. Luego, preparó y ejecutó una instrucción SQL utilizando PDO para obtener todos los elementos de la tabla products utilizando el comando SELECT * FROM products​​​.

      Luego, creó una tabla HTML y la completó con los datos de los productos utilizando la instrucción PHP while() {...}​​​. La línea $row = $stmt->fetch(PDO::FETCH_ASSOC)​​​ consulta la base de datos y almacena el resultado en la variable $row como matriz multidimensional, que luego se mostró en una columna de la tabla HTML utilizando la sintaxis $row['column_name']​​​.

      Las imágenes de la columna product_image se incluyen en el interior de las etiquetas <img src = "">. Se utilizan los atributos width y height para cambiar el tamaño de las imágenes por uno más pequeño que pueda caber en la columna de la tabla HTML.

      Para convertir los datos contenidos en el tipo de datos BLOB de vuelta en imágenes, se utilizan la función base64_encode de PHP integrada y la siguiente sintaxis para el esquema URI de datos:

      data:media_type;base64, base_64_encoded_data
      

      En este caso, imagen/png es media_type y la cadena codificada Base64 de la columna product_image es base_64_encoded_data.

      Luego, ejecute el archivo display_products.php en un navegador web escribiendo la siguiente dirección:

      http://your-server-IP/display_products.php
      

      Después de ejecutar el archivo display_products.php en su navegador, verá una tabla HTML con una lista de productos e imágenes asociados.

      Lista de productos de la base de datos MySQL

      Esto confirma que la secuencia de comandos de PHP para obtener imágenes de MySQL funciona según lo previsto.

      Conclusión

      A través de esta guía, utilizó el tipo de datos BLOB de MySQL para almacenar y mostrar imágenes con PHP en Ubuntu 18.04. También vio las ventajas básicas de almacenar imágenes en una base de datos respecto de hacerlo en un sistema de archivos. Entre ellas, se incluyen la portabilidad, la seguridad y la facilidad de respaldo. Si compila una aplicación, como un portal de estudiantes o una base de datos de empleados para los cuales se deban almacenar juntas la información y las imágenes relacionadas, esta tecnología puede resultarle muy útil.

      Para obtener más información sobre los tipos de datos compatibles en MySQL, consulte la guía de tipos de datos de MySQL. Si está interesado en más contenido relacionado con MySQL y PHP, consulte los siguientes tutoriales:



      Source link

      Cómo mostrar datos de la API de DigitalOcean con Django


      El autor seleccionó a Mozilla Foundation para recibir una donación como parte del programa Write for DOnations.

      Introducción

      A medida que continúa en aumento la demanda de desarrollo integral, los marcos web están haciendo que los flujos de trabajo de desarrollo sean menos complicados y más eficientes; Django es uno de esos marcos. Django se ha usado en sitios web importantes como Mozilla, Pinterest e Instagram. A diferencia de Flask, que es un micromarco neutral, el paquete PyPI de Django incluye todo lo que necesitaría para un desarrollo completo; sin necesidad de configurar una base de datos ni de controlar el panel para su desarrollo.

      Un caso de uso común para Django consiste en usarlo para mostrar información de las API (como publicaciones de Instagram o repositorios de GitHub) en sus aplicaciones y sitios web propios. Aunque esto es posible con otros marcos, la filosofía de “baterías incluidas” de Django implica que habrá menos problemas y se necesitarán menos paquetes para generar el mismo resultado.

      A través de este tutorial, creará un proyecto de Django que mostrará información del Droplet de su cuenta de DigitalOcean usando la API de DigitalOcean v2. En términos específicos, creará un sitio web que mostrará una tabla de Droplets listando cada ejemplar de sus direcciones IP, ID, regiones de hosting y recursos. Su sitio web usará BulmaCSS para dar estilo a la página, de modo que pueda concentrarse en el desarrollo y a la vez disponga de algo estético al final.

      Una vez completado este tutorial, dispondrá de un proyecto de Django que podrá producir una página web con el siguiente aspecto:

      Plantilla con tabla de datos del droplet

      Requisitos previos

      Para completar esta guía, necesitará lo siguiente:

      • Una cuenta de DigitalOcean con al menos un Droplet y un token de acceso personal. Asegúrese de registrar el token en un lugar seguro; lo necesitará más adelante en este tutorial.
      • Familiaridad al realizar solicitudes a API. Para ver un tutorial completo sobre cómo trabajar con API, consulte Cómo usar API web en Python3.
      • Un entorno virtual para Python para mantener dependencias. En este tutorial, usaremos el nombre do_django_api para el directorio de nuestro proyecto y env para nuestro entorno virtual.
      • Familiaridad con la lógica de plantillas de Django, para renderizar páginas con datos de API.
      • Familiaridad con la lógica de la vista de Django, para gestionar los datos recibidos de la API y proporcionarlos a una plantilla para su renderización.

      Paso 1: Crear un proyecto de Django básico

      Desde el entorno virtual env, instale Django:

      Ahora puede iniciar un proyecto de Django y ejecutar algunos comandos de configuración inicial.

      Utilice django-admin startproject <name> para crear en la carpeta del proyecto un subdirectorio que lleve el nombre del proyecto de Django. Luego posiciónese en ese directorio.

      • django-admin startproject do_django_project
      • cd do_django_project

      Una vez creado, dentro de este subdirectorio, encontrará manage.py, que es la alternativa habitual para interactuar con Django y ejecutar su proyecto. Utilice migrate para actualizar la base de datos de desarrollo de Django:

      • python3 manage.py migrate

      A medida que se actualice la base de datos, verá un resultado similar a este:

      Output

      Operations to perform: Apply all migrations: admin, auth, contenttypes, sessions Running migrations: Applying contenttypes.0001_initial... OK Applying auth.0001_initial... OK Applying admin.0001_initial... OK Applying admin.0002_logentry_remove_auto_add... OK Applying admin.0003_logentry_add_action_flag_choices... OK Applying contenttypes.0002_remove_content_type_name... OK Applying auth.0002_alter_permission_name_max_length... OK Applying auth.0003_alter_user_email_max_length... OK Applying auth.0004_alter_user_username_opts... OK Applying auth.0005_alter_user_last_login_null... OK Applying auth.0006_require_contenttypes_0002... OK Applying auth.0007_alter_validators_add_error_messages... OK Applying auth.0008_alter_user_username_max_length... OK Applying auth.0009_alter_user_last_name_max_length... OK Applying auth.0010_alter_group_name_max_length... OK Applying auth.0011_update_proxy_permissions... OK Applying sessions.0001_initial... OK

      A continuación, utilice el comando runserver para ejecutar el proyecto de modo que pueda probarlo:

      • python3 manage.py runserver

      El resultado tendrá este aspecto cuando se inicie el servidor:

      Output

      Watching for file changes with StatReloader Performing system checks... System check identified no issues (0 silenced). September 22, 2019 - 22:57:07 Django version 2.2.5, using settings 'do_django_project.settings' Starting development server at http://127.0.0.1:8000/ Quit the server with CONTROL-C.

      Ahora, dispondrá de un proyecto de Django básico y un servidor de desarrollo activo. Para ver su servidor de desarrollo activo, visite 127.0.0.1:8000 en un navegador. Mostrará la página de inicio de Django:

      Página de inicio genérica de Django

      A continuación, creará una aplicación de Django y configurará su proyecto para ejecutar una vista desde dicha aplicación. Por lo tanto, verá algo más interesante que la página predeterminada.

      Paso 2: Crear una aplicación de Django básica

      En este paso, creará el esqueleto de la aplicación que contendrá los resultados de su Droplet. Volverá a esta aplicación más tarde, una vez que haya configurado la invocación de API para completarla con datos.

      Asegúrese de que estar posicionado en el directorio do_django_project y cree una aplicación de Django usando el siguiente comando:

      • python3 manage.py startapp display_droplets

      Ahora, deberá añadir la nueva aplicación a INSTALLED_APPS en el archivo settings.py, de modo que Django la reconozca. settings.py es un archivo de configuración de Django que se ubica dentro de otro subdirectorio en el proyecto de Django y tiene el mismo nombre que la carpeta del proyecto (do_django_project). Django creó ambas carpetas. Posiciónese en el directorio do_django_project:

      Modifique settings.py en el editor que prefiera:

      Añada su nueva aplicación a la sección INSTALLED_APPS del archivo:

      do_django_api/do_django_project/do_django_project/settings.py

      INSTALLED_APPS = [
          'django.contrib.admin',
          'django.contrib.auth',
          'django.contrib.contenttypes',
          'django.contrib.sessions',
          'django.contrib.messages',
          'django.contrib.staticfiles',
          # The new app
          'display_droplets',
      ]
      

      Guarde y cierre el archivo cuando termine.

      Función de visualización GetDroplets

      A continuación, creará una función, GetDroplets, dentro del archivo views.py de la aplicación de display_droplets. Esta función creará la plantilla que usará para mostrar datos del Droplet, como context, desde la API. context es un diccionario que se usa para tomar datos del código Python y eviarlos a una plantilla HTML para que pueda mostrarse en una página web.

      Posiciónese en el directorio display_droplets:

      • cd ..
      • cd display_droplets

      Abra views.py para editarlo:

      Añada el siguiente código al archivo:

      do_django_api/do_django_project/display_droplets/views.py

      from django.views.generic import TemplateView
      
      class GetDroplets(TemplateView):
          template_name = 'droplets.html'
          def get_context_data(self, *args, **kwargs):
              pass
      

      Guarde y cierre el archivo.

      Más adelante, completará esta función y creará el archivo droplets.html, pero primero configuraremos urls.py para invocar esta función cuando visite el directorio root del servidor de desarrollo (127.0.0.1:8000).

      Vuelva al directorio del proyecto do_django_project:

      • cd ..
      • cd do_django_project

      Abra urls.py para su editarlo:

      Añada la instrucción import para GetDroplets, y luego una ruta adicional para urlpatterns que apuntará a la nueva vista.

      do_django_api/do_django_project/do_django_project/urls.py

      from django.contrib import admin
      from django.urls import path
      from display_droplets.views import GetDroplets
      
      urlpatterns = [
          path('admin/', admin.site.urls),
          path('', GetDroplets.as_view(template_name='droplets.html'), name='Droplet View'),
      ]
      

      Si desea crear sus propias rutas personalizadas, el primer parámetro es la URL (como example.com/**admin**), el segundo es la función que se invocará para producir la página web y el tercero simplemente el nombre de la ruta.

      Guarde y cierre el archivo.

      Platilla de Droplets

      A continuación, trabajará con plantillas. Las plantillas son archivos HTML que Django usa para crear páginas web. En este caso, usará una plantilla para crear una página HTML que muestre los datos de la API.

      Vuelva al directorio display_droplets:

      • cd ..
      • cd display_droplets

      Dentro de este, cree la carpeta template y posicónese en ella:

      • mkdir templates
      • cd templates

      Cree droplets.html y ábralo para editarlo:

      Para evitar tener que escribir cualquier tipo de CSS para este proyecto, usaremos Bulma CSS porque es un marco CSS gratuito y ligero que le permite crear páginas web de aspecto limpio simplemente añadiendo algunos atributos de clase al HTML.

      Ahora, crearemos una plantilla con una barra de naevgación básica. Añada el siguiente código al archivo droplets.html.

      do_django_api/do_django_project/display_droplets/templates/droplets.html

      <!DOCTYPE html>
      <html lang="en">
      <head>
          <meta charset="UTF-8">
          <title>DigitalOcean Droplets</title>
          <link crossorigin="anonymous"
                href="https://cdnjs.cloudflare.com/ajax/libs/bulma/0.7.4/css/bulma.min.css"
                integrity="sha256-8B1OaG0zT7uYA572S2xOxWACq9NXYPQ+U5kHPV1bJN4="
                rel="stylesheet"/>
          <link rel="shortcut icon" type="image/png" href="https://assets.digitalocean.com/logos/favicon.png"/>
      </head>
      <body>
      <nav aria-label="main navigation" class="navbar is-light" role="navigation">
          <div class="navbar-brand">
              <div class="navbar-item">
                  <img atl="DigitalOcean" src="https://assets.digitalocean.com/logos/DO_Logo_icon_blue.png"
                       style="margin-right: 0.5em;">Droplets
              </div>
          </div>
      </nav>
      </body>
      </html>
      

      Guarde y cierre el archivo.

      Este código importa Bulma a HTML estándar y crea la barra nav que muestra “Droplets”.

      Actualice la pestaña de su navegador para ver los cambios realizados en la plantilla.

      Plantilla con encabezado básico

      Hasta ahora, no intervino en nada relacionado con las API; creó una base para el proyecto. A continuación, pondrá en uso esta página creando una invocación de API y presentando los datos del Droplet.

      Paso 3: Crear la invocación de API

      En este paso, configurará una invocación de API y enviará los datos del Droplet como contexto para que la plantilla se muestre en una tabla.

      Obtener datos del Droplet

      Vuelva al directorio de la aplicación display_droplets:

      Instale la biblioteca requests para poder comunicarse con la API:

      La biblioteca requests permite que su código solicite datos de API y añada encabezados (datos adicionales enviados junto con nuestra solicitud).

      Ahora creará un archivo services.py, en el que realizará la invocación de la API. Esta función usará requests para comunicarse con https://api.digitalocean.com/v2/droplets y anexar cada Droplet en el archivo JSON devuelto a una lista.

      Abra services.py para editarlo:

      Añada el siguiente código al archivo:

      do_django_api/do_django_project/display_droplets/services.py

      import os
      import requests
      
      def get_droplets():
          url = 'https://api.digitalocean.com/v2/droplets'
          r = requests.get(url, headers={'Authorization':'Bearer %s' % 'access_token'})
          droplets = r.json()
          droplet_list = []
          for i in range(len(droplets['droplets'])):
              droplet_list.append(droplets['droplets'][i])
          return droplet_list
      

      Dentro de la función get_droplets pueden suceder dos cosas: se realiza una solicitud y se analizan los datos. url contiene los datos de la URL que solicita el Droplet de la API de DigitalOcean. r almacena los datos solicitados.

      requests toma dos parámetros en este caso: url y headers. Si desea datos de una API diferente, sustituirá el valor de url por la URL apropiada. headers envía a DigitalOcean su token de acceso a fin de que la plataforma verifique que tiene permiso para hacer la solicitud y confirme la cuenta para la cual se realiza la solicitud.

      droplets contiene la información de la variable r, pero ahora se convirtió a partir de JSON, el formato en el que cual API envía la información, en un diccionario fácil de usar en un bucle for.

      Con las siguientes tres líneas se crea una matriz, droplet_list[]​​​​. A continuación, un bucle for itera la información de los droplets y añade cada elemento a la lista. Toda la información tomada del API y almacenada en los droplets puede encontrarse en los documentos del desarrollador de DigitalOcean.

      Nota: No olvide sustituir access.token por su token de acceso. Además, guárdelo en un sitio seguro y nunca publique ese token en línea.

      Guarde y cierre el archivo.

      Proteger su token de acceso

      Siempre debería ocultar su token de acceso, pero si alguna vez alguien quisiera usar su proyecto, debería disponer de una alternativa sencilla para que esa persona pueda añadir su propio token de acceso sin tener que editar el código Python. DotENV es la solución, ya que las variables se guardan en un archivo .env que puede editarse de forma conveniente.

      Vuelva al directorio do_django_project.

      Para comenzar a trabajar con las variables de entorno, instale python-dotenv:

      • pip install python-dotenv

      Una vez que lo haga, deberá configurar Django para gestionar las variables de entorno de modo que pueda hacer referencia a ellas en el código. Para hacer eso, deberá añadir algunas líneas de código a manage.py y wsgi.py.

      Abra manage.py para editarlo:

      Añada el siguiente código:

      do_django_api/do_django_project/manage.py

      
      """Django's command-line utility for administrative tasks."""
      import os
      import sys
      import dotenv
      
      def main():
          os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'do_django_project.settings')
          try:
              from django.core.management import execute_from_command_line
          except ImportError as exc:
              raise ImportError(
                  "Couldn't import Django. Are you sure it's installed and "
                  "available on your PYTHONPATH environment variable? Did you "
                  "forget to activate a virtual environment?"
              ) from exc
          execute_from_command_line(sys.argv)
      
      if __name__ == '__main__':
          main()
      
      dotenv.load_dotenv(
          os.path.join(os.path.dirname(__file__), '.env')
      )
      

      Añadir esto en manage.py significa que cuando emita comandos a Django durante el desarrollo, gestionará las variables de entorno de su archivo .env.

      Guarde y cierre el archivo.

      Si alguna vez debe gestionar variables de entorno en sus proyectos de producción, podrá hacerlo desde el archivo wsgi.py. Posiciónese en el directorio do_django_project:

      Abra wsgi.py para su edición:

      Añada el siguiente código a wsgi.py:

      do_django_api/do_django_project/do_django_project/wsgi.py

      
      import os
      import dotenv
      
      from django.core.wsgi import get_wsgi_application
      
      os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'do_django_project.settings')
      
      dotenv.load_dotenv(
          os.path.join(os.path.dirname(os.path.dirname(__file__)), '.env')
      )
      
      application = get_wsgi_application()
      

      Este snippet de código tiene un os.path.dirname() adicional porque wsgi.py debe revisar nuevamente dos directorios para encontrar el archivo .env. Este snippet no es el mismo que se usa para manage.py.

      Guarde y cierre el archivo.

      Ahora puede usar una variable de entorno en services.py en vez de su token de acceso. Vuelva al directorio display_droplets:

      • cd ..
      • cd display_droplets

      Abra services.py para editarlo:

      Ahora sustituya su token de acceso por una variable de entorno.

      do_django_api/display_droplets/services.py

      import os
      import requests
      
      def get_droplets():
          url = "https://api.digitalocean.com/v2/droplets"
          r = requests.get(url, headers={'Authorization':'Bearer %s' % os.getenv('DO_ACCESS_TOKEN')})
          droplets = r.json()
          droplet_list = []
          for i in range(len(droplets['droplets'])):
              droplet_list.append(droplets['droplets'][i])
          return droplet_list
      

      Guarde y cierre el archivo.

      El siguiente paso es crear un archivo .env. Vuelva al directorio do_django_project:

      Cree un archivo .env y abra el archivo para editarlo:

      En .env, añada su token como la variable DO_ACCESS_TOKEN:

      do_django_api/do_django_project/.env

      DO_ACCESS_TOKEN=access_token
      

      Guarde y cierre el archivo.

      Nota: Añada .env a su archivo .gitignore para que nunca se incluya en sus ejecuciones.

      Con esto, configuró la conexión de la API y también protegió su token de acceso. Es el momento de presentar la información obtenida al usuario.

      Paso 4: Manipular datos del Droplet en vistas y plantillas

      Ahora que puede hacer invocaciones de API, deberá enviar los datos del Droplet a la plantilla para su representación. Regresaremos al módulo de la función, GetDroplets, que creó antes en views.py. En la función, enviará droplet_list como contexto a la plantilla droplets.html.

      Posiciónese en el directorio display_droplets:

      Abra views.py para editarlo:

      Añada el siguiente código a views.py:

      do_django_api/do_django_project/display_droplets/views.py

      from django.shortcuts import render
      from django.views.generic import TemplateView
      from .services import get_droplets
      
      class GetDroplets(TemplateView):
          template_name = 'droplets.html'
          def get_context_data(self, *args, **kwargs):
              context = {
                  'droplets' : get_droplets(),
              }
              return context
      

      La información enviada a la plantilla droplets.html se gestiona a través del diccionario context. Por eso, droplets funciona como clave y la matriz devuelta de get_droplets() como un valor.

      Guarde y cierre el archivo.

      Presentar los datos en la plantilla

      Dentro de la plantilla droplets.html, creará una tabla y la completará con los datos del Droplet.

      Posiciónese en el directorio templates:

      Abra droplets.html para editarlo:

      Añada el siguiente código después del elemento nav en droplets.html:

      do_django_api/do_django_project/display_droplets/templates/droplets.html

      <table class="table is-fullwidth is-striped is-bordered">
          <thead>
          <tr>
              <th>Name</th>
              <th>IPv4 Address(es)</th>
              <th>Id</th>
              <th>Region</th>
              <th>Memory</th>
              <th>CPUs</th>
              <th>Disk Size</th>
          </tr>
          </thead>
          <tbody>
          {% for droplet in droplets %}
          <tr>
              <th>{{ droplet.name }}</th>
              {% for ip in droplet.networks.v4 %}
              <td>{{ ip.ip_address }}</td>
              {% endfor %}
              <td>{{ droplet.id }}</td>
              <td>{{ droplet.region.name }}</td>
              <td>{{ droplet.memory }}</td>
              <td>{{ droplet.vcpus }}</td>
              <td>{{ droplet.disk }}</td>
          </tr>
          {% endfor %}
          </tbody>
      </table>
      

      {% for droplet in droplets %} ... {% endfor %} es un bucle que itera la matriz de Droplets recuperados de views.py. Cada Droplet se inserta en una fila de la tabla. Las diferentes líneas {{ droplet.<attribute> }}​​​ obtienen ese atributo para cada Droplet del bucle y lo insertan en una celda de tabla.​

      Guarde y cierre el archivo.

      Actualice su navegador para ver una lista de Droplets.

      Plantilla con tabla de datos de Droplets

      Ahora, podrá gestionar la API de DigitalOcean dentro de sus proyectos de Django. Tomó los datos obtenidos de la API y los incorporó a la plantilla que creó anteriormente, para mostrar la información de una forma legible y flexible.

      Conclusión

      A lo largo de este artículo, creó un proyecto de Django que puede mostrar información de Droplets de la API de DigitalOcean con estilo de CSS de Bulma. A través de este tutorial, aprendió tres habilidades importantes:

      • Gestión de solicitudes de API en Python usando los módulos requests y json.
      • Exposición de datos de API en un proyecto de Django usando la lógica de view y template.
      • Gestión segura de sus tokens de API usando dotenv en Django.

      Ahora que vio una introducción a la gestión de API en Django, puede crear un proyecto propio usando otra función de la API de DigitalOcean o una API diferente. También puede consultar otros tutoriales de Django o un tutorial similar con el marco React.





      Source link