MariaDB - Guía rápida

Existe una aplicación de base de datos separada de la aplicación principal y almacena colecciones de datos. Cada base de datos emplea una o varias API para la creación, acceso, administración, búsqueda y replicación de los datos que contiene.

Las bases de datos también utilizan fuentes de datos no relacionales como objetos o archivos. Sin embargo, las bases de datos resultan la mejor opción para grandes conjuntos de datos, que sufrirían de recuperación y escritura lentas con otras fuentes de datos.

Los sistemas de administración de bases de datos relacionales, o RDBMS, almacenan datos en varias tablas, las relaciones entre estas tablas se establecen utilizando claves primarias y claves externas.

RDBMS ofrece las siguientes características:

• Le permiten implementar una fuente de datos con tablas, columnas e índices.

• Garantizan la integridad de las referencias en filas de varias tablas.

• Actualizan automáticamente los índices.

• Interpretan consultas y operaciones SQL al manipular o obtener datos de tablas.

Terminología RDBMS

Antes de comenzar nuestra discusión sobre MariaDB, revisemos algunos términos relacionados con las bases de datos.

• Database - Una base de datos es una fuente de datos que consta de tablas que contienen datos relacionados.

• Table - Una tabla, es decir, una hoja de cálculo, es una matriz que contiene datos.

• Column- Una columna, que significa elemento de datos, es una estructura que contiene datos de un tipo; por ejemplo, fechas de envío.

• Row- Una fila es una estructura que agrupa datos relacionados; por ejemplo, datos de un cliente. También se conoce como tupla, entrada o registro.

• Redundancy - Este término se refiere a almacenar datos dos veces para acelerar el sistema.

• Primary Key- Esto se refiere a un valor identificativo único. Este valor no puede aparecer dos veces dentro de una tabla y solo hay una fila asociada a él.

• Foreign Key - Una clave externa sirve como enlace entre dos tablas.

• Compound Key- Una clave compuesta, o clave compuesta, es una clave que hace referencia a varias columnas. Se refiere a varias columnas debido a que una columna carece de una calidad única.

• Index - Un índice es prácticamente idéntico al índice de un libro.

• Referential Integrity - Este término se refiere a garantizar que todos los valores de clave externa apunten a filas existentes.

Base de datos MariaDB

MariaDB es una bifurcación popular de MySQL creada por los desarrolladores originales de MySQL. Surgió de preocupaciones relacionadas con la adquisición de MySQL por parte de Oracle. Ofrece soporte tanto para pequeñas tareas de procesamiento de datos como para las necesidades empresariales. Su objetivo es ser un reemplazo directo de MySQL que requiere solo una simple desinstalación de MySQL y una instalación de MariaDB. MariaDB ofrece las mismas características de MySQL y mucho más.

Características clave de MariaDB

Las características importantes de MariaDB son:

• Todo MariaDB está bajo GPL, LGPL o BSD.

• MariaDB incluye una amplia selección de motores de almacenamiento, incluidos motores de almacenamiento de alto rendimiento, para trabajar con otras fuentes de datos RDBMS.

• MariaDB utiliza un lenguaje de consulta estándar y popular.

• MariaDB se ejecuta en varios sistemas operativos y admite una amplia variedad de lenguajes de programación.

• MariaDB ofrece soporte para PHP, uno de los lenguajes de desarrollo web más populares.

• MariaDB ofrece tecnología de clúster Galera.

• MariaDB también ofrece muchas operaciones y comandos que no están disponibles en MySQL y elimina / reemplaza características que impactan negativamente en el rendimiento.

Empezando

Antes de comenzar este tutorial, asegúrese de tener algunos conocimientos básicos de PHP y HTML, específicamente el material discutido en nuestros tutoriales de PHP y HTML.

Esta guía se centra en el uso de MariaDB en un entorno PHP, por lo que nuestros ejemplos serán más útiles para los desarrolladores de PHP.

Recomendamos encarecidamente que revise nuestro Tutorial de PHP si no está familiarizado o necesita revisarlo.

Todas las descargas de MariaDB se encuentran en la sección de descargas del sitio web oficial de la fundación MariaDB. Haga clic en el enlace a la versión que desee y se mostrará una lista de descargas para varios sistemas operativos, arquitecturas y tipos de archivos de instalación.

Instalación en LINUX / UNIX

Si tiene un conocimiento profundo de los sistemas Linux / Unix, simplemente descargue el código fuente para construir su instalación. Nuestra forma recomendada de instalación es utilizar paquetes de distribución. MariaDB ofrece paquetes para las siguientes distribuciones de Linux / Unix:

• RedHat/CentOS/Fedora
• Debian/Ubuntu

Las siguientes distribuciones incluyen un paquete MariaDB en sus repositorios:

• openSUSE
• Arch Linux
• Mageia
• Mint
• Slackware

Siga estos pasos para instalar en un entorno Ubuntu:

Step 1 - Inicie sesión como usuario root.

Step 2 - Navegue hasta el directorio que contiene el paquete MariaDB.

Step 3 - Importe la clave de firma GnuPG con el siguiente código -

sudo apt-key adv --recv-keys --keyserver keyserver.ubuntu.com 0xcbcb082a1bb943db

Step 4 - Agregue MariaDB al sources.listarchivo. Abra el archivo y agregue el siguiente código:

sudo add-apt-repository 'deb http://ftp.osuosl.org/pub/mariadb/repo/5.5/ubuntuprecise main'

Step 5 - Actualice el sistema con lo siguiente -

sudo apt-get update

Step 6 - Instale MariaDB con lo siguiente -

sudo apt-get install mariadb-server

Instalación en Windows

Después de localizar y descargar un archivo de instalación automatizada (MSI), simplemente haga doble clic en el archivo para iniciar la instalación. El asistente de instalación lo guiará a través de cada paso de la instalación y cualquier configuración necesaria.

Pruebe la instalación iniciándola desde el símbolo del sistema. Navegue hasta la ubicación de la instalación, generalmente en el directorio, y escriba lo siguiente en el indicador:

mysqld.exe --console

Si la instalación es exitosa, verá mensajes relacionados con el inicio. Si esto no aparece, es posible que tenga problemas de permisos. Asegúrese de que su cuenta de usuario pueda acceder a la aplicación. Los clientes gráficos están disponibles para la administración de MariaDB en el entorno de Windows. Si encuentra la línea de comando incómoda o engorrosa, asegúrese de experimentar con ellos.

Prueba de la instalación

Realice algunas tareas simples para confirmar el funcionamiento y la instalación de MariaDB.

Use the Admin Utility to Get Server Status

Vea la versión del servidor con el binario mysqladmin.

[root@host]# mysqladmin --version

Debe mostrar la versión, distribución, sistema operativo y arquitectura. Si no ve el resultado de ese tipo, examine su instalación en busca de problemas.

Execute Simple Commands with a Client

Abra el símbolo del sistema para MariaDB. Esto debería conectarte con MariaDB y permitir la ejecución de comandos. Ingrese un comando simple de la siguiente manera:

mysql> SHOW DATABASES;

Posterior a la instalación

Después de la instalación exitosa de MariaDB, establezca una contraseña de root. Una nueva instalación tendrá una contraseña en blanco. Ingrese lo siguiente para establecer la nueva contraseña:

mysqladmin -u root password "[enter your password here]";

Ingrese lo siguiente para conectarse al servidor con sus nuevas credenciales:

mysql -u root -p
Enter password:*******

Actualización en Windows

Si ya tiene MySQL instalado en su sistema Windows y desea actualizar a MariaDB; no desinstale MySQL e instale MariaDB. Esto provocará un conflicto con la base de datos existente. En su lugar, debe instalar MariaDB y luego usar el asistente de actualización en el archivo de instalación de Windows.

Las opciones de su archivo MySQL my.cnf deberían funcionar con MariaDB. Sin embargo, MariaDB tiene muchas características que no se encuentran en MySQL.

Considere los siguientes conflictos en su archivo my.cnf:

• MariaDB usa el motor de almacenamiento Aria de forma predeterminada para archivos temporales. Si tiene muchos archivos temporales, modifique el tamaño del búfer de claves si no usa tablas MyISAM.

• Si sus aplicaciones se conectan / desconectan con frecuencia, modifique el tamaño de la caché de subprocesos.

• Si usa más de 100 conexiones, use el grupo de subprocesos.

Compatibilidad

MySQL y MariaDB son esencialmente idénticos. Sin embargo, existen suficientes diferencias para crear problemas en la actualización. Revise más de estas diferencias clave en la base de conocimientos de MariaDB.

Antes de intentar ejecutar MariaDB, primero determine su estado actual, en ejecución o apagado. Hay tres opciones para iniciar y detener MariaDB:

• Ejecute mysqld (el binario MariaDB).
• Ejecute el script de inicio mysqld_safe.
• Ejecute el script de inicio mysql.server.

Si instaló MariaDB en una ubicación no estándar, es posible que deba editar la información de ubicación en los archivos de script. Detenga MariaDB simplemente agregando un parámetro de "detención" con el script.

Si desea iniciarlo automáticamente en Linux, agregue scripts de inicio a su initsistema. Cada distribución tiene un procedimiento diferente. Consulte la documentación de su sistema.

Crear una cuenta de usuario

Cree una nueva cuenta de usuario con el siguiente código:

CREATE USER 'newusername'@'localhost' IDENTIFIED BY 'userpassword';

Este código agrega una fila a la tabla de usuarios sin privilegios. También tiene la opción de utilizar un valor hash para la contraseña. Otorgue privilegios al usuario con el siguiente código:

GRANT SELECT, INSERT, UPDATE, DELETE ON database1 TO 'newusername'@'localhost';

Otros privilegios incluyen casi todos los comandos u operaciones posibles en MariaDB. Después de crear un usuario, ejecute un comando "FLUSH PRIVILEGES" para actualizar las tablas de concesiones. Esto permite utilizar la cuenta de usuario.

El archivo de configuración

Después de una compilación en Unix / Linux, el archivo de configuración "/etc/mysql/my.cnf" debe editarse para que aparezca de la siguiente manera:

# Example mysql config file.
# You can copy this to one of:
# /etc/my.cnf to set global options,
# /mysql-data-dir/my.cnf to get server specific options or
# ~/my.cnf for user specific options.

#

# One can use all long options that the program supports.
# Run the program with --help to get a list of available options

# This will be passed to all mysql clients
[client]
#password = my_password
#port = 3306
#socket = /tmp/mysql.sock

# Here is entries for some specific programs
# The following values assume you have at least 32M ram

# The MySQL server
[mysqld]
#port = 3306
#socket = /tmp/mysql.sock
temp-pool

# The following three entries caused mysqld 10.0.1-MariaDB (and possibly other
   versions) to abort...
# skip-locking
# set-variable = key_buffer = 16M
# set-variable = thread_cache = 4

loose-innodb_data_file_path = ibdata1:1000M
loose-mutex-deadlock-detector
gdb

######### Fix the two following paths

# Where you want to have your database
data = /path/to/data/dir

# Where you have your mysql/MariaDB source + sql/share/english
language = /path/to/src/dir/sql/share/english

[mysqldump]
quick
MariaDB
8
set-variable = max_allowed_packet=16M
[mysql]
no-auto-rehash

[myisamchk]
set-variable = key_buffer = 128M

Edite las líneas "data =" e "language =" para que coincidan con su entorno.

Después de la modificación del archivo, navegue hasta el directorio de origen y ejecute lo siguiente:

./scripts/mysql_install_db --srcdir = $PWD --datadir = /path/to/data/dir -- user = $LOGNAME

Omita el "$PWD” variable if you added datadir to the configuration file. Ensure “$LOGNAME ”se utiliza cuando se ejecuta la versión 10.0.1 de MariaDB.

Comandos de administración

Revise la siguiente lista de comandos importantes que utilizará regularmente cuando trabaje con MariaDB:

• USE [database name] - Establece la base de datos predeterminada actual.

• SHOW DATABASES - Muestra las bases de datos que se encuentran actualmente en el servidor.

• SHOW TABLES - Lista todas las tablas no temporales.

• SHOW COLUMNS FROM [table name] - Proporciona información de columna perteneciente a la tabla especificada.

• SHOW INDEX FROM TABLENAME [table name] - Proporciona información de índice de tabla relacionada con la tabla especificada.

• SHOW TABLE STATUS LIKE [table name]\G – - Proporciona tablas con información sobre tablas no temporales y el patrón que aparece después de la cláusula LIKE se utiliza para buscar nombres de tablas.

MariaDB se asocia bien con una amplia variedad de lenguajes de programación y marcos como PHP, C #, JavaScript, Ruby on Rails, Django y más. PHP sigue siendo el más popular de todos los lenguajes disponibles debido a su simplicidad y huella histórica. Esta guía se centrará en PHP asociado con MariaDB.

PHP proporciona una selección de funciones para trabajar con la base de datos MySQL. Estas funciones realizan tareas como acceder a él o realizar operaciones, y son totalmente compatibles con MariaDB. Simplemente llame a estas funciones como llamaría a cualquier otra función PHP.

Las funciones PHP que utilizará para MariaDB se ajustan al siguiente formato:

mysql_function(value,value,...);

La segunda parte de la función especifica su acción. Dos de las funciones utilizadas en esta guía son las siguientes:

mysqli_connect($connect); mysqli_query($connect,"SQL statement");

El siguiente ejemplo demuestra la sintaxis general de una llamada de PHP a una función MariaDB:

<html>
   <head>
      <title>PHP and MariaDB</title>
   </head>

   <body>
      <?php
         $retval = mysql_function(value, [value,...]); if( !$retval ) {
            die ( "Error: Error message here" );
         }
         // MariaDB or PHP Statements
      ?>
   </body>
</html>

En la siguiente sección, examinaremos las tareas esenciales de MariaDB, utilizando funciones PHP.

Una forma de establecer una conexión con MariaDB consiste en usar el binario mysql en el símbolo del sistema.

MYSQL binario

Revise un ejemplo que se da a continuación.

[root@host]# mysql -u root -p

Enter password:******

El código proporcionado anteriormente se conecta a MariaDB y proporciona un símbolo del sistema para ejecutar comandos SQL. Después de ingresar el código, debería aparecer un mensaje de bienvenida indicando una conexión exitosa, con el número de versión mostrado.

Welcome to the MariaDB monitor. Commands end with ; or \g. 
Your MariaDB connection id is 122323232 
Server version: 5.5.40-MariaDB-log
  
Type 'help;' or '\h' for help. Type '\c' to clear the current input statement.  
mysql>

El ejemplo usa acceso de root, pero cualquier usuario con privilegios puede, por supuesto, acceder al indicador MariaDB y realizar operaciones.

Desconectarse de MariaDB a través del exit comando de la siguiente manera:

mysql> exit

Script de conexión PHP

Otra forma de conectarse y desconectarse de MariaDB consiste en emplear un script PHP. PHP proporciona lamysql_connect()función para abrir una conexión de base de datos. Utiliza cinco parámetros opcionales y devuelve un identificador de enlace MariaDB después de una conexión exitosa, o un falso en una conexión fallida. También proporcionamysql_close() función para cerrar las conexiones de la base de datos, que utiliza un solo parámetro.

Sintaxis

Revise la siguiente sintaxis del script de conexión PHP:

connection mysql_connect(server,user,passwd,new_link,client_flag);

La descripción de los parámetros se da a continuación:

No Señor	Descripción de parámetros
1	server Este parámetro opcional especifica el nombre de host que ejecuta el servidor de base de datos. Su valor predeterminado es "localhost: .3036".
2	user Este parámetro opcional especifica el nombre de usuario que accede a la base de datos. Su valor predeterminado es el propietario del servidor.
3	passwd Este parámetro opcional especifica la contraseña del usuario. Su valor predeterminado está en blanco.
4	new_link Este parámetro opcional especifica que en una segunda llamada a mysql_connect() con argumentos idénticos, en lugar de una nueva conexión, se devolverá el identificador de la conexión actual.
5	client flags Este parámetro opcional utiliza una combinación de los siguientes valores constantes: MYSQL_CLIENT_SSL: utiliza cifrado ssl. MYSQL_CLIENT_COMPRESS - Utiliza protocolo de compresión. MYSQL_CLIENT_IGNORE_SPACE: permite espacio después de los nombres de las funciones. MYSQL_CLIENT_INTERACTIVE: permite un tiempo de espera interactivo segundos de inactividad antes de cerrar la conexión.

Revise la sintaxis del script de desconexión de PHP que se proporciona a continuación:

bool mysql_close ( resource $link_identifier );

Si omite el recurso, se cerrará el recurso abierto más reciente. Devuelve un valor de verdadero en un cierre exitoso o falso.

Pruebe el siguiente código de ejemplo para conectarse con un servidor MariaDB:

<html>
   <head>
      <title>Connect to MariaDB Server</title>
   </head>

   <body>
      <?php
         $dbhost = 'localhost:3036';
         $dbuser = 'guest1'; $dbpass = 'guest1a';
         $conn = mysql_connect($dbhost, $dbuser, $dbpass);
      
         if(! $conn ) { die('Could not connect: ' . mysql_error()); } echo 'Connected successfully'; mysql_close($conn);
      ?>
   </body>
</html>

En una conexión exitosa, verá el siguiente resultado:

mysql> Connected successfully

La creación o eliminación de bases de datos en MariaDB requiere privilegios que generalmente solo se otorgan a usuarios raíz o administradores. En estas cuentas, tiene dos opciones para crear una base de datos: el binario mysqladmin y un script PHP.

mysqladmin binario

El siguiente ejemplo demuestra el uso del binario mysqladmin para crear una base de datos con el nombre Products -

[root@host]# mysqladmin -u root -p create PRODUCTS
Enter password:******

PHP Crear script de base de datos

PHP emplea el mysql_queryfunción en la creación de una base de datos MariaDB. La función usa dos parámetros, uno opcional, y devuelve un valor de "verdadero" cuando tiene éxito o "falso" cuando no.

Sintaxis

Revise lo siguiente create database script sintaxis -

bool mysql_query( sql, connection );

La descripción de los parámetros se da a continuación:

S. No	Descripción de parámetros
1	sql Este parámetro obligatorio consta de la consulta SQL necesaria para realizar la operación.
2	connection Cuando no se especifica, este parámetro opcional utiliza la conexión más reciente utilizada.

Pruebe el siguiente código de ejemplo para crear una base de datos:

<html>
   <head>
      <title>Create a MariaDB Database</title>
   </head>

   <body>
      <?php
         $dbhost = 'localhost:3036'; $dbuser = 'root';
         $dbpass = 'rootpassword'; $conn = mysql_connect($dbhost, $dbuser, $dbpass); if(! $conn ) {
            die('Could not connect: ' . mysql_error());
         }

         echo 'Connected successfully<br />';
         $sql = 'CREATE DATABASE PRODUCTS'; $retval = mysql_query( $sql, $conn );
      
         if(! $retval ) { die('Could not create database: ' . mysql_error()); } echo "Database PRODUCTS created successfully\n"; mysql_close($conn);
      ?>
   </body>
</html>

Una vez que se haya eliminado correctamente, verá el siguiente resultado:

mysql> Database PRODUCTS created successfully 
mysql> SHOW DATABASES; 
+-----------------------+ 
| Database              | 
+-----------------------+ 
| PRODUCTS              | 
+-----------------------+

La creación o eliminación de bases de datos en MariaDB requiere privilegios que, por lo general, solo se otorgan a usuarios raíz o administradores. En estas cuentas, tiene dos opciones para eliminar una base de datos: el binario mysqladmin y un script PHP.

Tenga en cuenta que las bases de datos eliminadas son irrecuperables, así que tenga cuidado al realizar esta operación. Además, los scripts PHP utilizados para la eliminación nonot le pedirá una confirmación antes de la eliminación.

mysqladmin binario

El siguiente ejemplo demuestra cómo usar el binario mysqladmin para eliminar una base de datos existente:

[root@host]# mysqladmin -u root -p drop PRODUCTS
Enter password:******
mysql> DROP PRODUCTS
ERROR 1008 (HY000): Can't drop database 'PRODUCTS'; database doesn't exist

Script PHP Drop de base de datos

PHP emplea el mysql_queryfunción en la eliminación de bases de datos MariaDB. La función usa dos parámetros, uno opcional, y devuelve un valor de "verdadero" cuando tiene éxito o "falso" cuando no.

Sintaxis

Revise la siguiente sintaxis del script de la base de datos de caída:

bool mysql_query( sql, connection );

La descripción de los parámetros se da a continuación:

No Señor	Descripción de parámetros
1	sql Este parámetro obligatorio consta de la consulta SQL necesaria para realizar la operación.
2	connection Cuando no se especifica, este parámetro opcional utiliza la conexión más reciente utilizada.

Pruebe el siguiente código de ejemplo para eliminar una base de datos:

<html>
   <head>
      <title>Delete a MariaDB Database</title>
   </head>

   <body>
      <?php
         $dbhost = 'localhost:3036'; $dbuser = 'root';
         $dbpass = 'rootpassword'; $conn = mysql_connect($dbhost, $dbuser, $dbpass); if(! $conn ) {
            die('Could not connect: ' . mysql_error());
         }
         echo 'Connected successfully<br />';
         
         $sql = 'DROP DATABASE PRODUCTS'; $retval = mysql_query( $sql, $conn );
         
         if(! $retval ){ die('Could not delete database: ' . mysql_error()); } echo "Database PRODUCTS deleted successfully\n"; mysql_close($conn);
      ?>
   </body>
</html>

Una vez que se haya eliminado correctamente, verá el siguiente resultado:

mysql> Database PRODUCTS deleted successfully

Después de conectarse a MariaDB, debe seleccionar una base de datos con la que trabajar porque pueden existir muchas bases de datos. Hay dos formas de realizar esta tarea: desde el símbolo del sistema o mediante un script PHP.

El símbolo del sistema

Al elegir una base de datos en el símbolo del sistema, simplemente utilice el comando SQL ‘use’ -

[root@host]# mysql -u root -p

Enter password:******

mysql> use PRODUCTS;

Database changed

mysql> SELECT database();  
+-------------------------+ 
| Database                | 
+-------------------------+ 
| PRODUCTS                | 
+-------------------------+

Una vez que seleccione una base de datos, todos los comandos posteriores operarán en la base de datos elegida.

Note- Todos los nombres (por ejemplo, base de datos, tabla, campos) distinguen entre mayúsculas y minúsculas. Asegúrese de que los comandos se ajusten al caso adecuado.

Script de base de datos PHP Select

PHP proporciona la mysql_select_dbfunción para la selección de la base de datos. La función usa dos parámetros, uno opcional y devuelve un valor de "verdadero" en una selección exitosa, o falso en caso de falla.

Sintaxis

Revise la siguiente sintaxis del script de selección de la base de datos.

bool mysql_select_db( db_name, connection );

La descripción de los parámetros se da a continuación:

S. No	Descripción de parámetros
1	db_name Este parámetro obligatorio especifica el nombre de la base de datos que se utilizará.
2	connection Cuando no se especifica, este parámetro opcional utiliza la conexión más reciente utilizada.

Pruebe el siguiente código de ejemplo para seleccionar una base de datos:

<html>
   <head>
      <title>Select a MariaDB Database</title>
   </head>

   <body>
      <?php
         $dbhost = 'localhost:3036'; $dbuser = 'guest1';
         $dbpass = 'guest1a'; $conn = mysql_connect($dbhost, $dbuser, $dbpass); if(! $conn ) {
            die('Could not connect: ' . mysql_error());
         }
         echo 'Connected successfully';
         
         mysql_select_db( 'PRODUCTS' );
         mysql_close($conn);
      ?>
   </body>
</html>

En una selección exitosa, verá el siguiente resultado:

mysql> Connected successfully

Las buenas definiciones de campo son esenciales para la optimización de su base de datos. El enfoque ideal requiere que utilice exclusivamente un campo del tipo y tamaño necesarios. Por ejemplo, si solo va a utilizar un campo de cinco caracteres de ancho, no defina un campo de 20 caracteres de ancho. Los tipos de campo (o columna) también se conocen como tipos de datos debido a los tipos de datos almacenados dentro del campo.

Los tipos de datos de MariaDB se pueden clasificar como valores numéricos, de fecha y hora y de cadena.

Tipos de datos numéricos

Los tipos de datos numéricos admitidos por MariaDB son los siguientes:

• TINYINT - Este tipo de datos representa pequeños enteros que se encuentran dentro del rango con signo de -128 a 127 y el rango sin signo de 0 a 255.

• BOOLEAN - Este tipo de datos asocia un valor 0 con "falso" y un valor 1 con "verdadero".

• SMALLINT - Este tipo de datos representa números enteros dentro del rango con signo de -32768 a 32768 y el rango sin signo de 0 a 65535.

• MEDIUMINT - Este tipo de datos representa números enteros en el rango con signo de -8388608 a 8388607, y el rango sin signo de 0 a 16777215.

• INT(also INTEGER)- Este tipo de datos representa un número entero de tamaño normal. Cuando se marca como sin firmar, el rango abarca de 0 a 4294967295. Cuando se firma (la configuración predeterminada), el rango abarca de -2147483648 a 2147483647. Cuando una columna se establece en ZEROFILL (un estado sin signo), todos sus valores se anteponen con ceros para colocar M dígitos en el valor INT.

• BIGINT - Este tipo de datos representa números enteros dentro del rango con signo de 9223372036854775808 a 9223372036854775807, y el rango sin signo de 0 a 18446744073709551615.

• DECIMAL(también DEC, NUMERIC, FIXED): este tipo de datos representa números precisos de coma fija, con M especificando sus dígitos y D especificando los dígitos después del decimal. El valor M no agrega “-” ni el punto decimal. Si D se establece en 0, no aparece ninguna parte decimal o fraccionaria y el valor se redondeará al DECIMAL más cercano en INSERT. El máximo de dígitos permitidos es 65 y el máximo de decimales es 30. El valor predeterminado para M en caso de omisión es 10 y 0 para D en caso de omisión.

• FLOAT - Este tipo de datos representa un pequeño número de punto flotante del valor 0 o un número dentro de los siguientes rangos -

  • -3.402823466E + 38 hasta -1.175494351E-38

  • 1.175494351E-38 hasta 3.402823466E + 38

• DOUBLE (además REAL y DOUBLE PRECISION) - Este tipo de datos representa números de punto flotante de tamaño normal del valor 0 o dentro de los siguientes rangos:

  • -1.7976931348623157E + 308 hasta -2.2250738585072014E-308

  • 2.2250738585072014E-308 hasta 1.7976931348623157E + 308

• BIT- Este tipo de datos representa campos de bits con M especificando el número de bits por valor. Si se omite M, el valor predeterminado es 1. Los valores de bit se pueden aplicar con “b '[valor]'” en el que el valor representa el valor de bit en 0 y 1. El relleno de ceros se produce automáticamente desde la izquierda en toda su longitud; por ejemplo, "10" se convierte en "0010".

Tipos de datos de fecha y hora

Los tipos de datos de fecha y hora admitidos por MariaDB son los siguientes:

• DATE - Este tipo de datos representa un rango de fechas de "1000-01-01" a "9999-12-31" y utiliza el formato de fecha "AAAA-MM-DD".

• TIME - Este tipo de datos representa un intervalo de tiempo de "-838: 59: 59.999999" a "838: 59: 59.999999".

• DATETIME- Este tipo de datos representa el rango "1000-01-01 00: 00: 00.000000" a "9999-12-31 23: 59: 59.999999". Utiliza el formato “AAAA-MM-DD HH: MM: SS”.

• TIMESTAMP- Este tipo de datos representa una marca de tiempo del formato “AAAA-MM-DD HH: MM: DD”. Se utiliza principalmente para detallar el momento de las modificaciones de la base de datos, por ejemplo, inserción o actualización.

• YEAR- Este tipo de datos representa un año en formato de 4 dígitos. El formato de cuatro dígitos permite valores en el rango de 1901 a 2155 y 0000.

String DataTypes

Los valores de tipo de cadena admitidos por MariaDB son los siguientes:

• String literals - Este tipo de datos representa secuencias de caracteres entre comillas.

• CHAR- Este tipo de datos representa una cadena de longitud fija rellenada a la derecha que contiene espacios de longitud especificada. M representa la longitud de columna de caracteres en un rango de 0 a 255, su valor predeterminado es 1.

• VARCHAR - Este tipo de datos representa una cadena de longitud variable, con un rango M (longitud máxima de columna) de 0 a 65535.

• BINARY - Este tipo de datos representa cadenas de bytes binarios, con M como la longitud de la columna en bytes.

• VARBINARY - Este tipo de datos representa cadenas de bytes binarios de longitud variable, con M como longitud de columna.

• TINYBLOB- Este tipo de datos representa una columna de blobs con una longitud máxima de 255 (28 - 1) bytes. En el almacenamiento, cada uno usa un prefijo de longitud de un byte que indica la cantidad de bytes en el valor.

• BLOB- Este tipo de datos representa una columna de blobs con una longitud máxima de 65,535 (216 - 1) bytes. En el almacenamiento, cada uno usa un prefijo de longitud de dos bytes que indica la cantidad de bytes en el valor.

• MEDIUMBLOB- Este tipo de datos representa una columna de blobs con una longitud máxima de 16.777.215 (2 ²⁴ - 1) bytes. En el almacenamiento, cada uno usa un prefijo de longitud de tres bytes que indica la cantidad de bytes en el valor.

• LONGBLOB- Este tipo de datos representa una columna de blobs con una longitud máxima de 4.294.967.295 (2 ³² - 1) bytes. En el almacenamiento, cada uno usa un prefijo de longitud de cuatro bytes que indica la cantidad de bytes en el valor.

• TINYTEXT- Este tipo de datos representa una columna de texto con una longitud máxima de 255 (2 ⁸ - 1) caracteres. En el almacenamiento, cada uno usa un prefijo de longitud de un byte que indica la cantidad de bytes en el valor.

• TEXT- Este tipo de datos representa una columna de texto con una longitud máxima de 65.535 (2 ¹⁶ - 1) caracteres. En el almacenamiento, cada uno usa un prefijo de longitud de dos bytes que indica la cantidad de bytes en el valor.

• MEDIUMTEXT- Este tipo de datos representa una columna de texto con una longitud máxima de 16.777.215 (2 ²⁴ - 1) caracteres. En el almacenamiento, cada uno usa un prefijo de longitud de tres bytes que indica la cantidad de bytes en el valor.

• LONGTEXT- Este tipo de datos representa una columna de texto con una longitud máxima de 4,294,967,295 o 4GB (2 ³² - 1) caracteres. En el almacenamiento, cada uno usa un prefijo de longitud de cuatro bytes que indica la cantidad de bytes en el valor.

• ENUM - Este tipo de datos representa un objeto de cadena que tiene un solo valor de una lista.

• SET- Este tipo de datos representa un objeto de cadena que tiene cero o más valores de una lista, con un máximo de 64 miembros. Los valores SET se presentan internamente como valores enteros.

En este capítulo, aprenderemos a crear tablas. Antes de crear una tabla, primero determine su nombre, los nombres de los campos y las definiciones de los campos.

A continuación se muestra la sintaxis general para la creación de tablas:

CREATE TABLE table_name (column_name column_type);

Revise el comando aplicado para crear una tabla en la base de datos de PRODUCTOS -

databaseproducts_ tbl(
   product_id INT NOT NULL AUTO_INCREMENT,
   product_name VARCHAR(100) NOT NULL,
   product_manufacturer VARCHAR(40) NOT NULL,
   submission_date DATE,
   PRIMARY KEY ( product_id )
);

El ejemplo anterior usa "NOT NULL" como atributo de campo para evitar errores causados ​​por un valor nulo. El atributo "AUTO_INCREMENT" indica a MariaDB que agregue el siguiente valor disponible al campo ID. La clave principal de la palabra clave define una columna comoprimary key. Varias columnas separadas por comas pueden definir una clave principal.

Los dos métodos principales para crear tablas son el símbolo del sistema y un script PHP.

El símbolo del sistema

Utilice el comando CREATE TABLE para realizar la tarea como se muestra a continuación:

root@host# mysql -u root -p
Enter password:*******
mysql> use PRODUCTS;
Database changed
mysql> CREATE TABLE products_tbl(
   -> product_id INT NOT NULL AUTO_INCREMENT,
   -> product_name VARCHAR(100) NOT NULL,
   -> product_manufacturer VARCHAR(40) NOT NULL,
   -> submission_date DATE,
   -> PRIMARY KEY ( product_id )
   -> );
mysql> SHOW TABLES;
+------------------------+
| PRODUCTS               |
+------------------------+
| products_tbl           |
+------------------------+

Asegúrese de que todos los comandos terminen con punto y coma.

Script PHP Crear tabla

PHP proporciona mysql_query()para la creación de tablas. Su segundo argumento contiene el comando SQL necesario:

<html>
   <head>
      <title>Create a MariaDB Table</title>
   </head>

   <body>
      <?php
         $dbhost = 'localhost:3036';
         $dbuser = 'root'; $dbpass = 'rootpassword';
         $conn = mysql_connect($dbhost, $dbuser, $dbpass);
      
         if(! $conn ){ die('Could not connect: ' . mysql_error()); } echo 'Connected successfully<br />'; $sql = "CREATE TABLE products_tbl( ".
            "product_id INT NOT NULL AUTO_INCREMENT, ".
            "product_name VARCHAR(100) NOT NULL, ".
            "product_manufacturer VARCHAR(40) NOT NULL, ".
            "submission_date DATE, ".
            "PRIMARY KEY ( product_id )); ";
      
         mysql_select_db( 'PRODUCTS' );
         $retval = mysql_query( $sql, $conn ); if(! $retval ) {
            die('Could not create table: ' . mysql_error());
         }
         echo "Table created successfully\n";
         
         mysql_close($conn);
      ?>
   </body>
</html>

En la creación exitosa de la tabla, verá el siguiente resultado:

mysql> Table created successfully

En este capítulo, aprenderemos a eliminar tablas.

La eliminación de tablas es muy fácil, pero recuerde que todas las tablas eliminadas son irrecuperables. La sintaxis general para la eliminación de tablas es la siguiente:

DROP TABLE table_name ;

Existen dos opciones para realizar una caída de la tabla: utilice el símbolo del sistema o un script PHP.

El símbolo del sistema

En el símbolo del sistema, simplemente use el DROP TABLE Comando SQL -

root@host# mysql -u root -p
Enter password:*******
mysql> use PRODUCTS;
Database changed
mysql> DROP TABLE products_tbl

mysql> SELECT * from products_tbl
ERROR 1146 (42S02): Table 'products_tbl' doesn't exist

Script PHP Drop Table

PHP proporciona mysql_query()para dejar caer las tablas. Simplemente pase su segundo argumento el comando SQL apropiado -

<html>
   <head>
      <title>Create a MariaDB Table</title>
   </head>

   <body>
      <?php
         $dbhost = 'localhost:3036';
         $dbuser = 'root'; $dbpass = 'rootpassword';
         $conn = mysql_connect($dbhost, $dbuser, $dbpass);
         
         if(! $conn ) { die('Could not connect: ' . mysql_error()); } echo 'Connected successfully<br />'; $sql = "DROP TABLE products_tbl";
         mysql_select_db( 'PRODUCTS' );
         $retval = mysql_query( $sql, $conn ); if(! $retval ) {
            die('Could not delete table: ' . mysql_error());
         }
         echo "Table deleted successfully\n";
         
         mysql_close($conn);
      ?>
   </body>
</html>

En la eliminación exitosa de la tabla, verá el siguiente resultado:

mysql> Table deleted successfully

En este capítulo, aprenderemos cómo insertar datos en una tabla.

Insertar datos en una tabla requiere el comando INSERT. La sintaxis general del comando es INSERT seguido del nombre de la tabla, los campos y los valores.

Revise su sintaxis general dada a continuación:

INSERT INTO tablename (field,field2,...) VALUES (value, value2,...);

La declaración requiere el uso de comillas simples o dobles para los valores de cadena. Otras opciones para la declaración incluyen declaraciones "INSERT ... SET", declaraciones "INSERT ... SELECT" y varias otras opciones.

Note - La función VALUES () que aparece dentro de la declaración, solo se aplica a las declaraciones INSERT y devuelve NULL si se usa en otro lugar.

Existen dos opciones para realizar la operación: usar la línea de comando o usar un script PHP.

El símbolo del sistema

Cuando se le solicite, hay muchas formas de realizar una operación de selección. A continuación se da una declaración estándar:

belowmysql>
INSERT INTO products_tbl (ID_number, Nomenclature) VALUES (12345,“Orbitron 4000”);
mysql> SHOW COLUMNS FROM products_tbl;
+-------------+-------------+------+-----+---------+-------+
| Field       | Type        | Null | Key | Default | Extra |
+-------------+-------------+------+-----+---------+-------+
| ID_number   | int(5)      |      |     |         |       |
| Nomenclature| char(13)    |      |     |         |       |
+-------------+-------------+------+-----+---------+-------+

Puede insertar varias filas -

INSERT INTO products VALUES (1, “first row”), (2, “second row”);

También puede emplear la cláusula SET -

INSERT INTO products SELECT * FROM inventory WHERE status = 'available';

Script de inserción PHP

Emplee la misma instrucción "INSERT INTO ..." dentro de una función PHP para realizar la operación. Usarás elmysql_query() funcionar una vez más.

Revise el ejemplo que se da a continuación:

<?php
   if(isset($_POST['add'])) {
      $dbhost = 'localhost:3036'; $dbuser = 'root';
      $dbpass = 'rootpassword'; $conn = mysql_connect($dbhost, $dbuser, $dbpass); if(! $conn ) {
         die('Could not connect: ' . mysql_error());
      }

      if(! get_magic_quotes_gpc() ) {
         $product_name = addslashes ($_POST['product_name']);
         $product_manufacturer = addslashes ($_POST['product_name']);
      } else {
         $product_name = $_POST['product_name'];
         $product_manufacturer = $_POST['product_manufacturer'];
      }
      $ship_date = $_POST['ship_date'];
      $sql = "INSERT INTO products_tbl ". "(product_name,product_manufacturer, ship_date) ". "VALUES"."('$product_name','$product_manufacturer','$ship_date')";

      mysql_select_db('PRODUCTS');
      $retval = mysql_query( $sql, $conn ); if(! $retval ) {
         die('Could not enter data: ' . mysql_error());
      }

      echo "Entered data successfully\n";
      mysql_close($conn);
   }
?>

En la inserción exitosa de datos, verá el siguiente resultado:

mysql> Entered data successfully

También colaborará con declaraciones de validación con declaraciones de inserción, como la verificación para garantizar la entrada correcta de datos. MariaDB incluye una serie de opciones para este propósito, algunas de las cuales son automáticas.

En este capítulo, aprenderemos a seleccionar datos de una tabla.

Las sentencias SELECT recuperan filas seleccionadas. Pueden incluir declaraciones UNION, una cláusula de ordenación, una cláusula LIMIT, una cláusula WHERE, una cláusula GROUP BY ... HAVING y subconsultas.

Revise la siguiente sintaxis general:

SELECT field, field2,... FROM table_name, table_name2,... WHERE...

Una instrucción SELECT proporciona múltiples opciones para especificar la tabla utilizada:

• database_name.table_name

• table_name.column_name

• database_name.table_name.column_name

Todas las declaraciones seleccionadas deben contener una o más select expressions. Las expresiones de selección constan de una de las siguientes opciones:

• Un nombre de columna.

• Una expresión que emplea operadores y funciones.

• La especificación "table_name. *" Para seleccionar todas las columnas dentro de la tabla dada.

• El carácter "*" para seleccionar todas las columnas de todas las tablas especificadas en la cláusula FROM.

Se puede utilizar el símbolo del sistema o un script PHP para ejecutar una instrucción de selección.

El símbolo del sistema

En el símbolo del sistema, ejecute declaraciones de la siguiente manera:

root@host# mysql -u root -p password;
Enter password:*******
mysql> use PRODUCTS;
Database changed
mysql> SELECT * from products_tbl
+-------------+---------------+
| ID_number   | Nomenclature  |
+-------------+---------------+
| 12345       | Orbitron 4000 |
+-------------+---------------+

PHP Seleccionar secuencia de comandos

Emplee las mismas instrucciones SELECT dentro de una función PHP para realizar la operación. Usarás elmysql_query()funcionar una vez más. Revise un ejemplo que se da a continuación:

<?php
   $dbhost = 'localhost:3036';
   $dbuser = 'root'; $dbpass = 'rootpassword';
   $conn = mysql_connect($dbhost, $dbuser, $dbpass);
   
   if(! $conn ) { die('Could not connect: ' . mysql_error()); } $sql = 'SELECT product_id, product_name,product_manufacturer, ship_date FROM products_tbl';
   mysql_select_db('PRODUCTS');
   $retval = mysql_query( $sql, $conn ); if(! $retval ) {
      die('Could not get data: ' . mysql_error());
   }

   while($row = mysql_fetch_array($retval, MYSQL_ASSOC)) {
      echo "Product ID :{$row['product_id']} <br> ". "Name: {$row['product_name']} <br> ".
         "Manufacturer: {$row['product_manufacturer']} <br> ". "Ship Date : {$row['ship_date']} <br>".
         "--------------------------------<br>";
   }

   echo "Fetched data successfully\n";
   mysql_close($conn);
?>

En la recuperación exitosa de datos, verá el siguiente resultado:

Product ID: 12345
Nomenclature: Orbitron 4000
Manufacturer: XYZ Corp
Ship Date: 01/01/17
----------------------------------------------
Product ID: 12346
Nomenclature: Orbitron 3000
Manufacturer: XYZ Corp
Ship Date: 01/02/17
----------------------------------------------
mysql> Fetched data successfully

Las mejores prácticas sugieren liberar la memoria del cursor después de cada instrucción SELECT. PHP proporciona lamysql_free_result()función para este propósito. Revise su uso como se muestra a continuación:

<?php
   $dbhost = 'localhost:3036';
   $dbuser = 'root'; $dbpass = 'rootpassword';
   $conn = mysql_connect($dbhost, $dbuser, $dbpass);
   
   if(! $conn ) { die('Could not connect: ' . mysql_error()); } $sql = 'SELECT product_id, product_name, product_manufacturer, ship_date FROM products_tbl';
   mysql_select_db('PRODUCTS');
   $retval = mysql_query( $sql, $conn ); if(! $retval ) {
      die('Could not get data: ' . mysql_error());
   }

   while($row = mysql_fetch_array($retval, MYSQL_NUM)) {
      echo "Product ID :{$row[0]} <br> ". "Name: {$row[1]} <br> ".
         "Manufacturer: {$row[2]} <br> ". "Ship Date : {$row[3]} <br> ".
         "--------------------------------<br>";
   }

   mysql_free_result($retval); echo "Fetched data successfully\n"; mysql_close($conn);
?>

WHERElas cláusulas filtran varias declaraciones como SELECT, UPDATE, DELETE e INSERT. Presentan criterios utilizados para especificar la acción. Por lo general, aparecen después del nombre de una tabla en una declaración, y su condición sigue. La cláusula WHERE funciona esencialmente como una declaración if.

Revise la sintaxis general de la cláusula WHERE dada a continuación:

[COMMAND] field,field2,... FROM table_name,table_name2,... WHERE [CONDITION]

Tenga en cuenta las siguientes cualidades de la cláusula WHERE:

• Es opcional.

• Permite especificar cualquier condición.

• Permite la especificación de múltiples condiciones mediante el uso de un operador AND u OR.

• La distinción entre mayúsculas y minúsculas solo se aplica a las declaraciones que utilizan comparaciones LIKE.

La cláusula WHERE permite el uso de los siguientes operadores:

Operador
=! =
> <
> = <=

Las cláusulas WHERE se pueden utilizar en el símbolo del sistema o dentro de un script PHP.

El símbolo del sistema

En el símbolo del sistema, simplemente use un comando estándar:

root@host# mysql -u root -p password;
Enter password:*******
mysql> use PRODUCTS;
Database changed
mysql> SELECT * from products_tbl WHERE product_manufacturer = 'XYZ Corp';
+-------------+----------------+----------------------+
| ID_number   | Nomenclature   | product_manufacturer |
+-------------+----------------+----------------------+
| 12345       | Orbitron 4000  | XYZ Corp             |
+-------------+----------------+----------------------+
| 12346       | Orbitron 3000  | XYZ Corp             |
+-------------+----------------+----------------------+
| 12347       | Orbitron 1000  | XYZ Corp             |
+-------------+----------------+----------------------+

Revise un ejemplo usando el AND condición -

SELECT *
FROM products_tbl
WHERE product_name = 'Bun Janshu 3000';
AND product_id <= 344;

Este ejemplo combina las condiciones AND y OR

SELECT *
FROM products_tbl
WHERE (product_name = 'Bun Janshu 3000' AND product_id < 344)
OR (product_name = 'Bun Janshu 3000');

Scripts PHP usando la cláusula Where

Emplear el mysql_query() función en operaciones usando una cláusula WHERE -

<?php
   $dbhost = 'localhost:3036'; $dbuser = 'root';
   $dbpass = 'rootpassword'; $conn = mysql_connect($dbhost, $dbuser, $dbpass); if(! $conn ) {
      die('Could not connect: ' . mysql_error());
   }

   $sql = 'SELECT product_id, product_name, product_manufacturer, ship_date FROM products_tbl WHERE product_manufacturer = "XYZ Corp"'; mysql_select_db('PRODUCTS'); $retval = mysql_query( $sql, $conn );
   
   if(! $retval ) { die('Could not get data: ' . mysql_error()); } while($row = mysql_fetch_array($retval, MYSQL_ASSOC)) { echo "Product ID :{$row['product_id']} <br> ".
         "Name: {$row['product_name']} <br> ". "Manufacturer: {$row['product_manufacturer']} <br> ".
         "Ship Date: {$row['ship_date']} <br> ". "--------------------------------<br>"; } echo "Fetched data successfully\n"; mysql_close($conn);
?>

En la recuperación exitosa de datos, verá el siguiente resultado:

Product ID: 12345
Nomenclature: Orbitron 4000
Manufacturer: XYZ Corp
Ship Date: 01/01/17
----------------------------------------------
Product ID: 12346
Nomenclature: Orbitron 3000
Manufacturer: XYZ Corp
Ship Date: 01/02/17
----------------------------------------------
Product ID: 12347
Nomenclature: Orbitron 1000
Manufacturer: XYZ Corp
Ship Date: 01/02/17
----------------------------------------------
mysql> Fetched data successfully

los UPDATEEl comando modifica los campos existentes cambiando los valores. Utiliza la cláusula SET para especificar las columnas que se van a modificar y para especificar los nuevos valores asignados. Estos valores pueden ser una expresión o el valor predeterminado del campo. Establecer un valor predeterminado requiere el uso de la palabra clave DEFAULT. El comando también puede emplear una cláusula WHERE para especificar condiciones para una actualización y / o una cláusula ORDER BY para actualizar en un orden determinado.

Revise la siguiente sintaxis general:

UPDATE table_name SET field=new_value, field2=new_value2,...
[WHERE ...]

Ejecute un comando UPDATE desde el símbolo del sistema o utilizando un script PHP.

El símbolo del sistema

En el símbolo del sistema, simplemente use una raíz de comando estándar:

root@host# mysql -u root -p password;
Enter password:*******
mysql> use PRODUCTS;
Database changed
mysql> UPDATE products_tbl
   SET nomenclature = 'Fiber Blaster 300Z' WHERE ID_number = 112;
mysql> SELECT * from products_tbl WHERE ID_number='112';
+-------------+---------------------+----------------------+
| ID_number   | Nomenclature        | product_manufacturer |
+-------------+---------------------+----------------------+
| 112         | Fiber Blaster 300Z  | XYZ Corp             |
+-------------+---------------------+----------------------+

Script de consulta de actualización de PHP

Emplear el mysql_query() función en las sentencias de comando ACTUALIZAR -

<?php
   $dbhost = ‘localhost:3036’; $dbuser = ‘root’;
   $dbpass = ‘rootpassword’; $conn = mysql_connect($dbhost, $dbuser, $dbpass); if(! $conn ) {
      die(‘Could not connect: ‘ . mysql_error());
   }

   $sql = ‘UPDATE products_tbl SET product_name = ”Fiber Blaster 300z” WHERE product_id = 112’; mysql_select_db(‘PRODUCTS’); $retval = mysql_query( $sql, $conn );

   if(! $retval ) { die(‘Could not update data: ‘ . mysql_error()); } echo “Updated data successfully\n”; mysql_close($conn);
?>

En la actualización de datos exitosa, verá el siguiente resultado:

mysql> Updated data successfully

El comando DELETE elimina las filas de la tabla de la tabla especificada y devuelve la cantidad eliminada. Acceda a la cantidad eliminada con la función ROW_COUNT (). Una cláusula WHERE especifica filas y, en su ausencia, todas las filas se eliminan. Una cláusula LIMIT controla el número de filas eliminadas.

En una instrucción DELETE para varias filas, elimina solo aquellas filas que satisfacen una condición; y las cláusulas LIMIT y WHERE no están permitidas. Las declaraciones DELETE permiten eliminar filas de tablas en diferentes bases de datos, pero no permiten eliminar de una tabla y luego seleccionar de la misma tabla dentro de una subconsulta.

Revise la siguiente sintaxis DELETE:

DELETE FROM table_name [WHERE …]

Ejecute un comando DELETE desde el símbolo del sistema o utilizando un script PHP.

El símbolo del sistema

En el símbolo del sistema, simplemente use un comando estándar:

root@host# mysql –u root –p password;
Enter password:*******
mysql> use PRODUCTS;
Database changed
mysql> DELETE FROM products_tbl WHERE product_id=133;
mysql> SELECT * from products_tbl WHERE ID_number='133';
ERROR 1032 (HY000): Can't find record in 'products_tbl'

Script de consulta de eliminación de PHP

Utilizar el mysql_query() función en las sentencias de comando DELETE -

<?php
   $dbhost = 'localhost:3036'; $dbuser = 'root';
   $dbpass = 'rootpassword'; $conn = mysql_connect($dbhost, $dbuser, $dbpass); if(! $conn ) {
      die('Could not connect: ' . mysql_error());
   }

   $sql = 'DELETE FROM products_tbl WHERE product_id = 261'; mysql_select_db('PRODUCTS'); $retval = mysql_query( $sql, $conn );

   if(! $retval ) { die('Could not delete data: ' . mysql_error()); } echo "Deleted data successfully\n"; mysql_close($conn);
?>

En la eliminación exitosa de datos, verá el siguiente resultado:

mysql> Deleted data successfully
mysql> SELECT * from products_tbl WHERE ID_number='261';
ERROR 1032 (HY000): Can't find record in 'products_tbl'

La cláusula WHERE proporciona una forma de recuperar datos cuando una operación usa una coincidencia exacta. En situaciones que requieren múltiples resultados con características compartidas, elLIKE La cláusula se adapta a una amplia coincidencia de patrones.

Una cláusula LIKE prueba la coincidencia de un patrón, devolviendo verdadero o falso. Los patrones utilizados para la comparación aceptan los siguientes caracteres comodín: "%", que coincide con números de caracteres (0 o más); y "_", que coincide con un solo carácter. El carácter comodín “_” solo coincide con caracteres dentro de su conjunto, lo que significa que ignorará los caracteres latinos cuando utilice otro conjunto. Las coincidencias no distinguen entre mayúsculas y minúsculas de forma predeterminada y requieren configuraciones adicionales para la distinción entre mayúsculas y minúsculas.

Una cláusula NOT LIKE permite probar la condición opuesta, al igual que la not operador.

Si la expresión de declaración o patrón se evalúa como NULL, el resultado es NULL.

Revise la sintaxis general de la cláusula LIKE que se proporciona a continuación:

SELECT field, field2,... FROM table_name, table_name2,...
WHERE field LIKE condition

Emplee una cláusula LIKE ya sea en el símbolo del sistema o dentro de un script PHP.

El símbolo del sistema

En el símbolo del sistema, simplemente use un comando estándar:

root@host# mysql -u root -p password;
Enter password:*******
mysql> use TUTORIALS;
Database changed
mysql> SELECT * from products_tbl
   WHERE product_manufacturer LIKE 'XYZ%';
+-------------+----------------+----------------------+
| ID_number   | Nomenclature   | product_manufacturer |
+-------------+----------------+----------------------+
| 12345       | Orbitron 4000  | XYZ Corp             |
+-------------+----------------+----------------------+
| 12346       | Orbitron 3000  | XYZ Corp             |
+-------------+----------------+----------------------+
| 12347       | Orbitron 1000  | XYZ Corp             |
+-------------+----------------+----------------------+

Script PHP con cláusula Like

Utilizar el mysql_query() función en declaraciones que emplean la cláusula LIKE

<?php
   $dbhost = 'localhost:3036'; $dbuser = 'root';
   $dbpass = 'rootpassword'; $conn = mysql_connect($dbhost, $dbuser, $dbpass); if(! $conn ) {
      die('Could not connect: ' . mysql_error());
   }

   $sql = 'SELECT product_id, product_name, product_manufacturer, ship_date FROM products_tbl WHERE product_manufacturer LIKE "xyz%"'; mysql_select_db('PRODUCTS'); $retval = mysql_query( $sql, $conn );
   
   if(! $retval ) { die('Could not get data: ' . mysql_error()); } while($row = mysql_fetch_array($retval, MYSQL_ASSOC)) { echo "Product ID:{$row['product_id']} <br> ".
         "Name: {$row['product_name']} <br> ". "Manufacturer: {$row['product_manufacturer']} <br> ".
         "Ship Date: {$row['ship_date']} <br> ". "--------------------------------<br>"; } echo "Fetched data successfully\n"; mysql_close($conn);
?>

En la recuperación exitosa de datos, verá el siguiente resultado:

Product ID: 12345
Nomenclature: Orbitron 4000
Manufacturer: XYZ Corp
Ship Date: 01/01/17
----------------------------------------------
Product ID: 12346
Nomenclature: Orbitron 3000
Manufacturer: XYZ Corp
Ship Date: 01/02/17
----------------------------------------------
Product ID: 12347
Nomenclature: Orbitron 1000
Manufacturer: XYZ Corp
Ship Date: 01/02/17
----------------------------------------------
mysql> Fetched data successfully

los ORDER BYcláusula, como se mencionó en discusiones anteriores, ordena los resultados de una declaración. Especifica el orden de los datos operados e incluye la opción de ordenar en orden ascendente (ASC) o descendente (DESC). En caso de omisión de la especificación del pedido, el orden predeterminado es ascendente.

Las cláusulas ORDER BY aparecen en una amplia variedad de declaraciones como DELETE y UPDATE. Siempre aparecen al final de una declaración, no en una subconsulta o antes de una función establecida, porque operan en la tabla resultante final. Tampoco puede utilizar un número entero para identificar una columna.

Revise la sintaxis general de la cláusula ORDER BY que se indica a continuación:

SELECT field, field2,... [or column] FROM table_name, table_name2,...
ORDER BY field, field2,... ASC[or DESC]

Utilice una cláusula ORDER BY en el símbolo del sistema o dentro de un script PHP.

El símbolo del sistema

En el símbolo del sistema, simplemente use un comando estándar:

root@ host# mysql -u root -p password;
Enter password:*******
mysql> use PRODUCTS;
Database changed

mysql> SELECT * from products_tbl ORDER BY product_manufacturer ASC
+-------------+----------------+----------------------+
| ID_number   | Nomenclature   | product_manufacturer |
+-------------+----------------+----------------------+
| 56789       | SuperBlast 400 | LMN Corp             |
+-------------+----------------+----------------------+
| 67891       | Zoomzoom 5000  | QFT Corp             |
+-------------+----------------+----------------------+
| 12347       | Orbitron 1000  | XYZ Corp             |
+-------------+----------------+----------------------+

Script PHP usando la cláusula Order By

Utilice el mysql_query() función, una vez más, en declaraciones que emplean la cláusula ORDER BY -

<?php
   $dbhost = 'localhost:3036'; $dbuser = 'root';
   $dbpass = 'rootpassword'; $conn = mysql_connect($dbhost, $dbuser, $dbpass); if(! $conn ) {
      die('Could not connect: ' . mysql_error());
   }

   $sql = 'SELECT product_id, product_name, product_manufacturer, ship_date FROM products_tbl ORDER BY product_manufacturer DESC'; mysql_select_db('PRODUCTS'); $retval = mysql_query( $sql, $conn );

   if(! $retval ) { die('Could not get data: ' . mysql_error()); } while($row = mysql_fetch_array($retval, MYSQL_ASSOC)) { echo "Product ID :{$row['product_id']} <br> ".
         "Name: {$row['product_name']} <br> ". "Manufacturer: {$row['product_manufacturer']} <br> ".
         "Ship Date : {$row['ship_date']} <br> ". "--------------------------------<br>"; } echo "Fetched data successfully\n"; mysql_close($conn);
?>

En la recuperación exitosa de datos, verá el siguiente resultado:

Product ID: 12347
Nomenclature: Orbitron 1000
Manufacturer: XYZ Corp
Ship Date: 01/01/17
----------------------------------------------
Product ID: 67891
Nomenclature: Zoomzoom 5000
Manufacturer: QFT Corp
Ship Date: 01/01/17
----------------------------------------------
Product ID: 56789
Nomenclature: SuperBlast 400
Manufacturer: LMN Corp
Ship Date: 01/04/17
----------------------------------------------
mysql> Fetched data successfully

En discusiones y ejemplos anteriores, examinamos la recuperación de una sola tabla o la recuperación de múltiples valores de múltiples fuentes. La mayoría de las operaciones de datos del mundo real son mucho más complejas y requieren agregación, comparación y recuperación de varias tablas.

JOINspermiten la fusión de dos o más tablas en un solo objeto. Se emplean mediante sentencias SELECT, UPDATE y DELETE.

Revise la sintaxis general de una declaración que emplea un JOIN como se muestra a continuación:

SELECT column
FROM table_name1
INNER JOIN table_name2
ON table_name1.column = table_name2.column;

Tenga en cuenta que la antigua sintaxis de JOINS usaba combinaciones implícitas y sin palabras clave. Es posible utilizar una cláusula WHERE para lograr una unión, pero las palabras clave funcionan mejor para mejorar la legibilidad, el mantenimiento y las mejores prácticas.

Las UNIONES vienen en muchas formas, como una combinación izquierda, una combinación derecha o una combinación interna. Varios tipos de combinación ofrecen diferentes tipos de agregación basados ​​en valores o características compartidos.

Emplee un JOIN en el símbolo del sistema o con un script PHP.

El símbolo del sistema

En el símbolo del sistema, simplemente use una declaración estándar:

root@host# mysql -u root -p password;
Enter password:*******
mysql> use PRODUCTS;
Database changed

mysql> SELECT products.ID_number, products.Nomenclature, inventory.inventory_ct
   FROM products
   INNER JOIN inventory
   ON products.ID_numbeer = inventory.ID_number;
+-------------+----------------+-----------------+
| ID_number   | Nomenclature   | Inventory Count |
+-------------+----------------+-----------------+
| 12345       | Orbitron 4000  | 150             |
+-------------+----------------+-----------------+
| 12346       | Orbitron 3000  | 200             |
+-------------+----------------+-----------------+
| 12347       | Orbitron 1000  | 0               |
+-------------+----------------+-----------------+

Script PHP usando JOIN

Utilizar el mysql_query() función para realizar una operación de unión -

<?php
   $dbhost = 'localhost:3036'; $dbuser = 'root';
   $dbpass = 'rootpassword'; $conn = mysql_connect($dbhost, $dbuser, $dbpass); if(! $conn ) {
      die('Could not connect: ' . mysql_error());
   }

   $sql = 'SELECT a.product_id, a.product_manufacturer, b.product_count FROM products_tbl a, pcount_tbl b WHERE a.product_manufacturer = b.product_manufacturer'; mysql_select_db('PRODUCTS'); $retval = mysql_query( $sql, $conn );

   if(! $retval ) { die('Could not get data: ' . mysql_error()); } while($row = mysql_fetch_array($retval, MYSQL_ASSOC)) { echo "Manufacturer:{$row['product_manufacturer']} <br> ".
         "Count: {$row['product_count']} <br> ". "Product ID: {$row['product_id']} <br> ".
         "--------------------------------<br>";
   }

   echo "Fetched data successfully\n";
   mysql_close($conn);
?>

En la recuperación exitosa de datos, verá el siguiente resultado:

ID Number: 12345
Nomenclature: Orbitron 4000
Inventory Count: 150
--------------------------------------
ID Number: 12346
Nomenclature: Orbitron 3000
Inventory Count: 200
--------------------------------------
ID Number: 12347
Nomenclature: Orbitron 1000
Inventory Count: 0
--------------------------------------
mysql> Fetched data successfully

Cuando trabaje con valores NULL, recuerde que son valores desconocidos. No son cadenas vacías ni cero, que son valores válidos. En la creación de tablas, las especificaciones de columna permiten configurarlas para aceptar valores nulos o rechazarlos. Simplemente utilice una cláusula NULL o NOT NULL. Esto tiene aplicaciones en casos de información de registro faltante como un número de identificación.

Las variables definidas por el usuario tienen un valor de NULL hasta la asignación explícita. Los parámetros de rutina almacenados y las variables locales permiten establecer un valor de NULL. Cuando una variable local no tiene un valor predeterminado, tiene un valor de NULL.

NULL no distingue entre mayúsculas y minúsculas y tiene los siguientes alias:

• DESCONOCIDO (un valor booleano)
• \N

Operadores NULL

Los operadores de comparación estándar no se pueden usar con NULL (por ejemplo, =,>,> =, <=, <o! =) Porque todas las comparaciones con un valor NULL devuelven NULL, ni verdadero ni falso. Las comparaciones con NULL o que posiblemente lo contengan deben usar el operador “<=>” (NULL-SAFE).

Otros operadores disponibles son:

• ES NULO: prueba un valor NULO.

• NO ES NULO: confirma la ausencia de un valor NULO.

• ISNULL: devuelve un valor de 1 al descubrir un valor NULL y 0 en su ausencia.

• COALESCE: devuelve el primer valor no NULO de una lista, o devuelve un valor NULO en ausencia de uno.

Ordenar valores NULL

En las operaciones de clasificación, los valores NULL tienen el valor más bajo, por lo que el orden DESC da como resultado valores NULL en la parte inferior. MariaDB permite establecer un valor más alto para valores NULL.

Hay dos formas de hacer esto, como se muestra a continuación:

SELECT column1 FROM product_tbl ORDER BY ISNULL(column1), column1;

Al revés

SELECT column1 FROM product_tbl ORDER BY IF(column1 IS NULL, 0, 1), column1 DESC;

Funciones NULL

Las funciones generalmente generan NULL cuando los parámetros son NULL. Sin embargo, existen funciones diseñadas específicamente para administrar valores NULL. Ellos son -

• IFNULL()- Si la primera expresión no es NULL, la devuelve. Cuando se evalúa como NULL, devuelve la segunda expresión.

• NULLIF() - Devuelve NULL cuando las expresiones comparadas son iguales, si no, devuelve la primera expresión.

Funciones como SUM y AVG ignoran los valores NULL.

Insertar valores NULL

Al insertar un valor NULL en una columna declarada NO NULL, se produce un error. En el modo SQL predeterminado, una columna NOT NULL insertará un valor predeterminado basado en el tipo de datos.

Cuando un campo es TIMESTAMP, AUTO_INCREMENT o columna virtual, MariaDB administra los valores NULL de manera diferente. La inserción en una columna AUTO_INCREMENT hace que el siguiente número de la secuencia se inserte en su lugar. En un campo TIMESTAMP, MariaDB asigna la marca de tiempo actual. En las columnas virtuales, un tema que se analiza más adelante en este tutorial, se asigna el valor predeterminado.

Los índices UNIQUE pueden contener muchos valores NULL, sin embargo, las claves primarias no pueden ser NULL.

Valores NULL y el comando Alter

Cuando usa el comando ALTER para modificar una columna, en ausencia de especificaciones NULL, MariaDB asigna valores automáticamente.

Más allá de la coincidencia de patrones disponible en las cláusulas LIKE, MariaDB ofrece una coincidencia basada en expresiones regulares a través del operador REGEXP. El operador realiza una coincidencia de patrones para una expresión de cadena basada en un patrón dado.

MariaDB 10.0.5 introdujo Expresiones regulares PCRE, que aumenta drásticamente el alcance de la coincidencia en áreas como patrones recursivos, aserciones anticipadas y más.

Revise el uso de la sintaxis estándar del operador REGEXP que se indica a continuación:

SELECT column FROM table_name WHERE column REGEXP '[PATTERN]';

REGEXP devuelve 1 para una coincidencia de patrón o 0 en ausencia de uno.

Existe una opción para lo contrario en forma de NOT REGEXP. MariaDB también ofrece sinónimos para REGEXP y NOT REGEXP, RLIKE y NOT RLIKE, que fueron creados por razones de compatibilidad.

El patrón comparado puede ser una cadena literal o algo más, como una columna de tabla. En cadenas, utiliza la sintaxis de escape de C, por lo que duplica los caracteres "\". REGEXP tampoco distingue entre mayúsculas y minúsculas, con la excepción de las cadenas binarias.

A continuación se muestra una tabla de posibles patrones que se pueden utilizar:

No Señor	Patrón y descripción
1	^ Coincide con el inicio de la cadena.
2	$ Coincide con el final de la cuerda.
3	. Coincide con un solo carácter.
4	[...] Coincide con cualquier carácter entre paréntesis.
5	[^...] Coincide con cualquier carácter que no figure entre paréntesis.
6	p1|p2|p3 Coincide con cualquiera de los patrones.
7	* Coincide con 0 o más instancias del elemento anterior.
8	+ Coincide con 1 o más instancias del elemento anterior.
9	{n} Coincide con n instancias del elemento anterior.
10	{m,n} Coincide con m an instancias del elemento anterior.

Revise los ejemplos de coincidencia de patrones que se dan a continuación:

Productos que comienzan con "pr" -

SELECT name FROM product_tbl WHERE name REGEXP '^pr';

Productos que terminan con "na":

SELECT name FROM product_tbl WHERE name REGEXP 'na$';

Productos que comienzan con una vocal -

SELECT name FROM product_tbl WHERE name REGEXP '^[aeiou]';

Las transacciones son operaciones de grupo secuenciales. Funcionan como una sola unidad y no terminan hasta que todas las operaciones dentro del grupo se ejecutan con éxito. Un solo error en el grupo hace que toda la transacción falle y no tenga ningún impacto en la base de datos.

Las transacciones se ajustan a ACID (atomicidad, consistencia, aislamiento y durabilidad) -

• Atomicity - Asegura el éxito de todas las operaciones al abortar las fallas y revertir los cambios.

• Consistency - Asegura que la base de datos aplique cambios en una transacción exitosa.

• Isolation - Permite la operación de transacciones independientes de transacciones.

• Durability - Asegura la persistencia de una transacción exitosa en caso de falla del sistema.

Al principio de una declaración de transacción se encuentra la declaración START TRANSACTION seguida de las declaraciones COMMIT y ROLLBACK:

• INICIAR TRANSACCIÓN comienza la transacción.

• COMMIT guarda los cambios en los datos.

• ROLLBACK finaliza la transacción, destruyendo cualquier cambio.

En una transacción exitosa, COMMIT actúa. En caso de falla, ROLLBACK actúa.

Note- Algunas declaraciones provocan un compromiso implícito y también provocan un error cuando se utilizan dentro de las transacciones. Ejemplos de tales declaraciones incluyen, pero no se limitan a CREATE, ALTER y DROP.

Las transacciones MariaDB también incluyen opciones como SAVEPOINT y LOCK TABLES. SAVEPOINT establece un punto de restauración para utilizar con ROLLBACK. LOCK TABLES permite controlar el acceso a las tablas durante las sesiones para evitar modificaciones durante ciertos períodos de tiempo.

La variable AUTOCOMMIT proporciona control sobre las transacciones. Un valor de 1 obliga a que todas las operaciones se consideren transacciones exitosas, y un valor de 0 hace que la persistencia de cambios solo ocurra en una declaración COMMIT explícita.

Estructura de una transacción

La estructura general de una declaración de transacción consiste en comenzar con INICIAR TRANSACCIÓN. El siguiente paso es insertar uno o más comandos / operaciones, insertar declaraciones que comprueben errores, insertar declaraciones ROLLBACK para administrar cualquier error descubierto y finalmente insertar una declaración COMMIT para aplicar cambios en operaciones exitosas.

Revise el ejemplo que se da a continuación:

START TRANSACTION;
SELECT name FROM products WHERE manufacturer = 'XYZ Corp';
UPDATE spring_products SET item = name;
COMMIT;

El comando ALTER proporciona una forma de cambiar la estructura de una tabla existente, es decir, modificaciones como eliminar o agregar columnas, modificar índices, cambiar tipos de datos o cambiar nombres. ALTER también espera para aplicar cambios cuando un bloqueo de metadatos está activo.

Usar ALTER para modificar columnas

ALTER emparejado con DROP elimina una columna existente. Sin embargo, falla si la columna es la única columna restante.

Revise el ejemplo que se da a continuación:

mysql> ALTER TABLE products_tbl DROP version_num;

Use una instrucción ALTER ... ADD para agregar columnas -

mysql> ALTER TABLE products_tbl ADD discontinued CHAR(1);

Utilice las palabras clave PRIMERO y DESPUÉS para especificar la ubicación de la columna:

ALTER TABLE products_tbl ADD discontinued CHAR(1) FIRST;
ALTER TABLE products_tbl ADD discontinued CHAR(1) AFTER quantity;

Tenga en cuenta que las palabras clave FIRST y AFTER solo se aplican a las declaraciones ALTER ... ADD. Además, debe soltar una tabla y luego agregarla para reposicionarla.

Cambie la definición o el nombre de una columna utilizando la cláusula MODIFY o CHANGE en una instrucción ALTER. Las cláusulas tienen efectos similares, pero utilizan una sintaxis sustancialmente diferente.

Revise un ejemplo de CAMBIO que se muestra a continuación:

mysql> ALTER TABLE products_tbl CHANGE discontinued status CHAR(4);

En una declaración que usa CAMBIAR, especifique la columna original y luego la nueva columna que la reemplazará. Revise un ejemplo de MODIFICAR a continuación:

mysql> ALTER TABLE products_tbl MODIFY discontinued CHAR(4);

El comando ALTER también permite cambiar los valores predeterminados. Revise un ejemplo:

mysql> ALTER TABLE products_tbl ALTER discontinued SET DEFAULT N;

También puede usarlo para eliminar las restricciones predeterminadas combinándolo con una cláusula DROP:

mysql> ALTER TABLE products_tbl ALTER discontinued DROP DEFAULT;

Usar ALTER para modificar tablas

Cambiar el tipo de tabla con la cláusula TYPE -

mysql> ALTER TABLE products_tbl TYPE = INNODB;

Cambiar el nombre de una tabla con la palabra clave RENAME -

mysql> ALTER TABLE products_tbl RENAME TO products2016_tbl;

Los índices son herramientas para acelerar la recuperación de registros. Un índice genera una entrada para cada valor dentro de una columna indexada.

Hay cuatro tipos de índices:

• Primary (un registro representa todos los registros)

• Unique (un registro representa varios registros)

• Plain

• Full-Text (permite muchas opciones en búsquedas de texto).

Los términos "clave" e "índice" son idénticos en este uso.

Los índices se asocian con una o más columnas y admiten búsquedas rápidas y una organización de registros eficiente. Al crear un índice, tenga en cuenta qué columnas se utilizan con frecuencia en sus consultas. Luego, cree uno o varios índices en ellos. Además, vea los índices como esencialmente tablas de claves primarias.

Aunque los índices aceleran las búsquedas o las sentencias SELECT, hacen que las inserciones y actualizaciones se arrastren debido a que realizan las operaciones tanto en las tablas como en los índices.

Crear un índice

Puede crear un índice mediante una sentencia CREATE TABLE ... INDEX o una sentencia CREATE INDEX. La mejor opción que respalda la legibilidad, el mantenimiento y las mejores prácticas es CREAR ÍNDICE.

Revise la sintaxis general del índice que se proporciona a continuación:

CREATE [UNIQUE or FULLTEXT or...] INDEX index_name ON table_name column;

Revise un ejemplo de su uso -

CREATE UNIQUE INDEX top_sellers ON products_tbl product;

Suelta un índice

Puede quitar un índice con DROP INDEX o ALTER TABLE ... DROP. La mejor opción que respalda la legibilidad, el mantenimiento y las mejores prácticas es DROP INDEX.

Revise la sintaxis general de Drop Index que se indica a continuación:

DROP INDEX index_name ON table_name;

Revise un ejemplo de su uso -

DROP INDEX top_sellers ON product_tbl;

Cambiar el nombre de un índice

Cambie el nombre de un índice con la instrucción ALTER TABLE. Revise su sintaxis general dada a continuación:

ALTER TABLE table_name DROP INDEX index_name, ADD INDEX new_index_name;

Revise un ejemplo de su uso -

ALTER TABLE products_tbl DROP INDEX top_sellers, ADD INDEX top_2016sellers;

Gestión de índices

Deberá examinar y realizar un seguimiento de todos los índices. Utilice SHOW INDEX para enumerar todos los índices existentes asociados con una tabla determinada. Puede establecer el formato del contenido mostrado mediante una opción como "\ G", que especifica un formato vertical.

Revise el siguiente ejemplo:

mysql > SHOW INDEX FROM products_tbl\G

Estadísticas de tabla

Los índices se utilizan mucho para optimizar las consultas dado el acceso más rápido a los registros y las estadísticas proporcionadas. Sin embargo, muchos usuarios encuentran engorroso el mantenimiento de índices. MariaDB 10.0 puso a disposición tablas de estadísticas independientes del motor de almacenamiento, que calculan estadísticas de datos para cada tabla en cada motor de almacenamiento, e incluso estadísticas para columnas que no están indexadas.

Algunas operaciones pueden beneficiarse de tablas temporales debido a la velocidad o los datos desechables. La vida de una tabla temporal termina al finalizar una sesión, ya sea que la utilice desde el símbolo del sistema, con un script PHP o mediante un programa cliente. Tampoco aparece en el sistema de forma típica. El comando SHOW TABLES no revelará una lista que contenga tablas temporales.

Crear una tabla temporal

La palabra clave TEMPORARY dentro de una instrucción CREATE TABLE genera una tabla temporal. Revise un ejemplo que se da a continuación:

mysql>CREATE TEMPORARY TABLE order (
   item_name VARCHAR(50) NOT NULL
   , price DECIMAL(7,2) NOT NULL DEFAULT 0.00
   , quantity INT UNSIGNED NOT NULL DEFAULT 0
);

Al crear una tabla temporal, puede clonar tablas existentes, es decir, todas sus características generales, con la cláusula LIKE. La instrucción CREATE TABLE utilizada para generar la tabla temporal no confirmará transacciones como resultado de la palabra clave TEMPORARY.

Aunque las tablas temporales se distinguen de las no temporales y caen al final de una sesión, pueden tener ciertos conflictos:

• A veces entran en conflicto con tablas temporales fantasma de sesiones caducadas.

• A veces entran en conflicto con nombres de sombra de tablas no temporales.

Note - Se permite que las tablas temporales tengan el mismo nombre que una tabla no temporal existente porque MariaDB la ve como una referencia de diferencia.

Administración

MariaDB requiere otorgar privilegios a los usuarios para crear tablas temporales. Utilice una declaración GRANT para otorgar este privilegio a los usuarios que no son administradores.

GRANT CREATE TEMPORARY TABLES ON orders TO 'machine122'@'localhost';

Suelta una mesa temporal

Aunque las tablas temporales se eliminan esencialmente al final de las sesiones, tiene la opción de eliminarlas. Eliminar una tabla temporal requiere el uso de la palabra clave TEMPORARY, y las mejores prácticas sugieren eliminar las tablas temporales antes que las no temporales.

mysql> DROP TABLE order;

Algunas situaciones requieren producir una copia exacta de una tabla existente. La instrucción CREATE ... SELECT no puede producir esta salida porque descuida cosas como índices y valores predeterminados.

El procedimiento para duplicar una tabla es el siguiente:

• Utilice SHOW CREATE TABLE para producir una declaración CREATE TABLE que detalle toda la estructura de la tabla fuente.

• Edite la instrucción para darle a la tabla un nuevo nombre y ejecútela.

• Utilice una instrucción INSERT INTO ... SELECT si también necesita que se copien los datos de la tabla.

mysql> INSERT INTO inventory_copy_tbl (
   product_id,product_name,product_manufacturer,ship_date)
   
   SELECT product_id,product_name,product_manufacturer,ship_date,
   FROM inventory_tbl;

Otro método para crear un duplicado usa una instrucción CREATE TABLE AS. La declaración copia todas las columnas, definiciones de columna y completa la copia con los datos de la tabla de origen.

Revise su sintaxis dada a continuación:

CREATE TABLE clone_tbl AS
   SELECT columns
   FROM original_tbl
   WHERE conditions];

Revise un ejemplo de su uso a continuación:

CREATE TABLE products_copy_tbl AS
   SELECT *
   FROM products_tbl;

En la versión 10.0.3, MariaDB introdujo un motor de almacenamiento conocido como secuencia. Su ad hoc genera una secuencia de enteros para las operaciones y luego termina. La secuencia contiene números enteros positivos en orden descendente o ascendente, y usa un valor inicial, final e incremental.

No permite su uso en múltiples consultas, solo en su consulta original debido a su naturaleza virtual (no escrita en disco). Sin embargo, las tablas de secuencia se pueden convertir en tablas estándar mediante un comando ALTER. Si se elimina una tabla convertida, la tabla de secuencia aún existe. Las secuencias tampoco pueden producir números negativos o rotar al mínimo / máximo.

Instalación del motor de secuencia

El uso de secuencias requiere instalar el motor de secuencia, que MariaDB distribuye como un complemento en lugar de binario. Instálelo con el siguiente comando:

INSTALL SONAME "ha_sequence";

Después de la instalación, verifíquelo:

SHOW ENGINES\G

Recuerde que después de la instalación del motor, no puede crear una tabla estándar con un nombre que use sintaxis de secuencia, pero puede crear una tabla temporal con un nombre de sintaxis de secuencia.

Creando secuencia

Hay dos métodos de creación de secuencias:

• Cree una tabla y utilice el atributo AUTO_INCREMENT para definir una columna como autoincremento.

• Utilice una base de datos existente y utilice una consulta SELECT de secuencia para producir una secuencia. La consulta utiliza la sintaxis seq_ [FROM] _to_ [TO] o seq_ [FROM] _to_ [TO] _step_STEP.

Las mejores prácticas prefieren el uso del segundo método. Revise un ejemplo de creación de una secuencia que se muestra a continuación:

SELECT * FROM seq_77_to_99;

Las secuencias tienen muchos usos:

• Localice los valores faltantes dentro de una columna para protegerse contra problemas relacionados en las operaciones:

SELECT myseq.seq FROM seq_22_to_28 myseq LEFT JOIN table1 t ON myseq.seq
   = x.y WHERE x.y IS NULL;

• Construya una combinación de valores -

SELECT x1.seq, x2.seq FROM seq_5_to_9 x1 JOIN seq_5_to_9 x2 ORDER BY 5, 6;

• Encuentra múltiplos de un número -

SELECT seq FROM seq_3_to_100_step_4;

• Construya una secuencia de fechas para usar en aplicaciones como sistemas de reserva.
• Construye una secuencia de tiempo.

MariaDB, como se discutió en lecciones anteriores, permite duplicar registros y tablas en algunas situaciones. Algunos de estos duplicados no son de hecho duplicados debido a distintos tipos de datos o objetos, o como resultado de una vida útil o almacenamiento únicos del objeto de operación. Estos duplicados tampoco suelen plantear problemas.

En algunas situaciones, los duplicados causan problemas y, a menudo, aparecen debido a acciones implícitas o la política indulgente de un comando MariaDB. Hay formas de controlar este problema, encontrar duplicados, eliminar duplicados y evitar la creación de duplicados.

Estrategias y herramientas

Hay cuatro formas clave de administrar duplicados:

• Pesquelos con JOIN y elimínelos con una tabla temporal.

• Utilice INSERT ... ON DUPLICATE KEY UPDATE para actualizar al descubrir un duplicado.

• Utilice DISTINCT para eliminar los resultados de una instrucción SELECT y eliminar los duplicados.

• Utilice INSERT IGNORE para detener la inserción de duplicados.

Uso de Unir con una tabla temporal

Simplemente realice una semi-unión como una unión interna y luego elimine los duplicados encontrados con una tabla temporal.

Usando INSERT

Cuando INSERT ... ON DUPLICATE KEY UPDATE descubre una clave única o principal duplicada, realiza una actualización. Al descubrir varias claves únicas, actualiza solo la primera. Por lo tanto, no lo use en tablas con múltiples índices únicos.

Revise el siguiente ejemplo, que revela lo que sucede en una tabla que contiene valores indexados al insertarlos en un campo poblado:

INSERT INTO add_dupl VALUES (1,'Apple');
ERROR 1062 (23000): Duplicate entry '1' for key 'PRIMARY'

Note - Si no encuentra ninguna clave, una instrucción INSERT ... ON DUPLICATE KEY UPDATE se ejecuta como una instrucción de inserción normal.

Usando DISTINCT

Las cláusulas DISTINCT eliminan los duplicados de los resultados. La sintaxis general de una cláusula DISTINCT es la siguiente:

SELECT DISTINCT fields
FROM table
[WHERE conditions];

Note - Los resultados de una declaración con una cláusula DISTINCT -

• Cuando se usa una expresión, devuelve valores únicos para ella.

• Cuando usa múltiples expresiones, devuelve combinaciones únicas.

• No ignora los valores NULL; por lo tanto, los resultados también contienen NULL como valores únicos.

Revise la siguiente declaración utilizando una cláusula DISTINCT para una sola expresión:

SELECT DISTINCT product_id
FROM products
WHERE product_name = 'DustBlaster 5000';

Revise el siguiente ejemplo usando múltiples expresiones:

SELECT DISTINCT product_name, product_id
FROM products
WHERE product_id < 30

Usando INSERT IGNORE

Una instrucción INSERT IGNORE le indica a MariaDB que cancele la inserción al descubrir un registro duplicado. Revise un ejemplo de su uso que se da a continuación:

mysql> INSERT IGNORE INTO customer_tbl (LN, FN)
   VALUES( 'Lex', 'Luther');

Además, tenga en cuenta la lógica detrás de los duplicados. Algunas tablas requieren duplicados según la naturaleza de los datos de esa tabla. Adapte esa necesidad a su estrategia de gestión de registros duplicados.

El simple hecho de aceptar la entrada del usuario abre la puerta a las vulnerabilidades. El problema surge principalmente de la gestión lógica de los datos, pero afortunadamente, es bastante fácil evitar estos defectos importantes.

Las oportunidades para la inyección de SQL generalmente ocurren cuando los usuarios ingresan datos como un nombre y la lógica del código no analiza esta entrada. El Código, en cambio, permite a un atacante insertar una declaración MariaDB, que se ejecutará en la base de datos.

Siempre considere los datos ingresados ​​por los usuarios, sospechosos y que necesitan una validación sólida antes de cualquier procesamiento. Realice esta validación mediante la coincidencia de patrones. Por ejemplo, si la entrada esperada es un nombre de usuario, restrinja los caracteres ingresados ​​a caracteres alfanuméricos y guiones bajos, y a una cierta longitud. Revise un ejemplo que se da a continuación:

if(check_match("/^\w{8,20}$/", $_GET['user_name'], $matches)) {
   $result = mysql_query("SELECT * FROM system_users WHERE user_name = $matches[0]");
} else {
   echo "Invalid username";
}

Además, utilice el operador REGEXP y las cláusulas LIKE para crear restricciones de entrada.

Considere todos los tipos de control explícito necesario de la entrada, como:

• Controla los caracteres de escape utilizados.

• Controle los tipos de datos apropiados específicos para la entrada. Limite la entrada al tipo y tamaño de datos necesarios.

• Controle la sintaxis de los datos ingresados. No permita nada fuera del patrón necesario.

• Controle los términos permitidos. Lista negra de palabras clave SQL.

Puede que no conozca los peligros de los ataques por inyección, o puede que los considere insignificantes, pero encabezan la lista de preocupaciones de seguridad. Además, considere el efecto de estas dos entradas:

1=1
-or-
*

El código que permite ingresar cualquiera de ellos junto con el comando correcto puede resultar en revelar todos los datos del usuario en la base de datos o eliminar todos los datos en la base de datos, y ninguna inyección es particularmente inteligente. En algunos casos, los atacantes ni siquiera dedican tiempo a examinar los agujeros; realizan ataques a ciegas con una entrada simple.

Además, considere las herramientas de expresión regular y coincidencia de patrones que proporciona cualquier lenguaje de programación / scripting emparejado con MariaDB, que brindan más control y, a veces, mejor control.

Los datos sirven como la base del negocio y las operaciones, y con varias amenazas posibles (p. Ej., Atacantes, fallas del sistema, malas actualizaciones y errores de mantenimiento), las copias de seguridad siguen siendo críticas. Estas copias de seguridad adoptan muchas formas y existen muchas opciones para crearlas con un conjunto aún más amplio de opciones dentro de esos procesos. Las cosas importantes a recordar son el tipo de base de datos, la información crítica y la estructura involucrada. Esta información determina su mejor opción.

OPCIONES

Las principales opciones para las copias de seguridad incluyen copias de seguridad lógicas y copias de seguridad físicas. Las copias de seguridad lógicas contienen declaraciones SQL para restaurar datos. Las copias de seguridad físicas contienen copias de datos.

• Logical backupsofrecen la flexibilidad de restaurar datos en otra máquina con una configuración diferente en contraste con las copias de seguridad físicas, que a menudo se limitan a la misma máquina y tipo de base de datos. Las copias de seguridad lógicas ocurren a nivel de base de datos y de tabla, y las físicas ocurren a nivel de directorio y archivo.

• Physical backupsson más pequeños que los lógicos y también requieren menos tiempo para realizarlos y restaurarlos. Las copias de seguridad físicas también incluyen archivos de registro y configuración, pero las copias de seguridad lógicas no.

Herramientas de respaldo

La principal herramienta utilizada para las copias de seguridad de MariaDB es mysqldump. Ofrece copias de seguridad lógicas y flexibilidad. También resulta una excelente opción para bases de datos pequeñas.Mysqldumpvuelca datos en SQL, CSV, XML y muchos otros formatos. Su salida no retiene los procedimientos almacenados, las vistas y los eventos sin instrucciones explícitas.

Hay tres opciones para mysqldump copias de seguridad -

• Raw data - Volcar una tabla como un archivo de datos sin procesar a través de la opción --tab, que también especifica el destino del archivo -

$ mysqldump -u root -p --no-create-info \
   --tab=/tmp PRODUCTS products_tbl

• Data/Definitions export- Esta opción permite exportar una o varias tablas a un archivo y permite realizar copias de seguridad de todas las bases de datos existentes en la máquina host. Examinar un ejemplo de exportación de contenidos o definiciones a un archivo.

$ mysqldump -u root -p PRODUCTS products_tbl > export_file.txt

• Transfer - También puede enviar bases de datos y tablas a otro host

$ mysqldump -u root -p database_name \
   | mysql -h other-host.com database_name

Uso de la instrucción SELECT ... INTO OUTFILE

Otra opción para exportar datos emplea la instrucción SELECT ... INTO OUTFILE. Esta simple opción genera la tabla en un archivo de texto con formato simple:

mysql> SELECT * FROM products_tbl
   -> INTO OUTFILE '/tmp/products.txt';

Sus atributos permiten formatear el archivo según sus especificaciones preferidas.

Tenga en cuenta las siguientes cualidades de esta declaración:

• El nombre del archivo debe especificar la ubicación deseada para la salida.

• Necesita privilegios de archivo MariaDB para ejecutar la declaración.

• El nombre del archivo de salida debe ser exclusivo.

• Necesita credenciales de inicio de sesión en el host.

• En un entorno UNIX, el archivo de salida se puede leer en todo el mundo, pero la propiedad del servidor afecta su capacidad para eliminarlo. Asegúrese de tener privilegios.

Uso de CONNECT en copias de seguridad

El controlador CONNECT permite exportar datos. Esto resulta útil principalmente en situaciones en las que la operación SELECT ... INTO OUTFILE no admite el formato de archivo.

Revise el siguiente ejemplo:

create table products
engine = CONNECT table_type = XML file_name = 'products.htm' header = yes
option_list = 'name = TABLE,coltype = HTML,attribute = border = 1;cellpadding = 5'

select plugin_name handler, plugin_version version, plugin_author
author, plugin_description description, plugin_maturity maturity
from information_schema.plugins where plugin_type = 'STORAGE ENGINE';

Otras herramientas

Otras opciones para las copias de seguridad son las siguientes:

• XtraBackup- Esta opción se dirige a las bases de datos XtraDB / InnoDB y funciona con cualquier motor de almacenamiento. Obtenga más información sobre esta herramienta en el sitio oficial de Percona.

• Snapshots- Algunos sistemas de archivos permiten instantáneas. El proceso consiste en vaciar las tablas con bloqueo de lectura, montar la instantánea, desbloquear las tablas, copiar la instantánea y luego desmontar la instantánea.

• LVM- Este método popular emplea un script Perl. Obtiene un bloqueo de lectura en cada tabla y descarga las cachés en el disco. Luego obtiene una instantánea y desbloquea las tablas. Consultar al funcionariomylvmbackup sitio web para obtener más información.

• TokuBackup- Esta solución proporcionada por Percona proporciona copias de seguridad en caliente teniendo en cuenta los problemas y limitaciones de las opciones de copia de seguridad de InnoDB. Produce una copia de sonido transaccional de los archivos mientras las aplicaciones continúan manipulándolos.Consulte el sitio web de Percona para obtener más información.

Consideraciones de INNODB

InnoDB utiliza un grupo de búfer para mejorar el rendimiento. En una copia de seguridad, configure InnoDB para evitar copiar una tabla completa en el grupo de búfer porque las copias de seguridad lógicas suelen realizar escaneos completos de la tabla.

En este capítulo, aprenderemos sobre varios métodos de carga de copias de seguridad. Restaurar una base de datos a partir de una copia de seguridad es un proceso simple y, a veces, terriblemente largo.

Hay tres opciones para cargar datos: la instrucción LOAD DATA, mysqlimport y una simple restauración de mysqldump.

Usando LOAD DATA

La sentencia LOAD DATA funciona como un cargador masivo. Revise un ejemplo de su uso que carga un archivo de texto:

mysql> LOAD DATA LOCAL INFILE 'products_copy.txt' INTO TABLE empty_tbl;

Tenga en cuenta las siguientes cualidades de una declaración LOAD DATA:

• Use la palabra clave LOCAL para evitar que MariaDB realice una búsqueda profunda del host y use una ruta muy específica.

• La declaración asume un formato que consta de líneas terminadas por avances de línea (nuevas líneas) y valores de datos separados por tabulaciones.

• Utilice la cláusula FIELDS para especificar explícitamente el formato de los campos en una línea. Utilice la cláusula LINES para especificar el final de línea. Revise un ejemplo a continuación.

mysql> LOAD DATA LOCAL INFILE 'products_copy.txt' INTO TABLE empty_tbl
   FIELDS TERMINATED BY '|'
   LINES TERMINATED BY '\n';

• La declaración asume que las columnas dentro del archivo de datos usan el mismo orden de la tabla. Si necesita establecer un orden diferente, puede cargar el archivo de la siguiente manera:

mysql> LOAD DATA LOCAL INFILE 'products_copy.txt' INTO TABLE empty_tbl (c, b, a);

Usando MYSQLIMPORT

La herramienta mysqlimport actúa como un contenedor LOAD DATA que permite las mismas operaciones desde la línea de comandos.

Cargue los datos de la siguiente manera:

$ mysqlimport -u root -p --local database_name source_file.txt

Especifique el formato de la siguiente manera:

$ mysqlimport -u root -p --local --fields-terminated-by="|" \
   --lines-terminated-by="\n" database_name source_file.txt

Utilizar el --columns opción para especificar el orden de las columnas -

$ mysqlimport -u root -p --local --columns=c,b,a \
   database_name source_file.txt

Usando MYSQLDUMP

Restaurando con mysqldump requiere esta simple declaración para volver a cargar el archivo de volcado en el host:

shell> mysql database_name < source_file.sql

PERSONAJES ESPECIALES Y COTIZACIONES

En una instrucción LOAD DATA, es posible que las comillas y los caracteres especiales no se interpreten correctamente. La declaración asume valores sin comillas y trata las barras invertidas como caracteres de escape. Utilice la cláusula FIELDS para especificar el formato. Señale las comillas con "ENCLOSED BY", lo que provoca la eliminación de las comillas de los valores de datos. Cambie los escapes con "ESCAPED BY".

Este capítulo contiene una lista de las funciones más utilizadas, que ofrece definiciones, explicaciones y ejemplos.

Funciones agregadas de MariaDB

Las funciones agregadas más utilizadas se dan a continuación:

No Señor	Nombre y descripción
1	COUNT Cuenta el número de registros. Example - SELECCIONAR COUNT (*) FROM customer_table;
2	MIN Revela el valor mínimo de un conjunto de registros. Example - SELECCIONAR organización, MIN (cuenta) DE contratos GRUPO POR organización;
3	MAX Revela el valor máximo de un conjunto de registros. Example - SELECCIONAR organización, MAX (account_size) FROM contratos GROUP BY organización;
4	AVG Calcula el valor medio de un conjunto de registros. Example - SELECT AVG (account_size) FROM contratos;
5	SUM Calcula la suma de un conjunto de registros. Example - SELECCIONAR SUM (tamaño_cuenta) DE los contratos;

Cálculo de la edad de MariaDB

los TIMESTAMPDIFF La función proporciona una forma de calcular la edad:

SELECT CURDATE() AS today;
SELECT ID, DOB, TIMESTAMPDIFF(YEAR,DOB,'2015-07-01') AS age FROM officer_info;

Concatenación de cadenas MariaDB

los CONCATLa función devuelve la cadena resultante después de una operación de concatenación. Puede utilizar uno o más argumentos. Revise su sintaxis dada a continuación:

SELECT CONCAT(item, item,...);

Revise el siguiente ejemplo:

SELECT CONCAT('Ram', 'bu', 'tan');
Output:Rambutan

Funciones de fecha / hora de MariaDB

A continuación se muestran importantes funciones de fecha:

No Señor	Nombre y descripción
1	CURDATE() Devuelve la fecha en formato aaaa-mm-dd o aaaammdd. Example - SELECCIONAR CURDATE ();
2	DATE() Devuelve la fecha en múltiples formatos. Example −CREAR TABLA product_release_tbl (x FECHA);
3	CURTIME() Devuelve la hora en formato HH: MM: SS o HHMMSS.uuuuuu. Example - SELECCIONAR HORA ();
4	DATE_SUB() Agrega o resta varios días a la fecha especificada. Example - SELECCIONAR FECHA_SUB ('2016-02-08', INTERVALO 60 DÍAS);
5	DATEDIFF() Determina los días entre dos fechas. Example - SELECCIONAR DATEDIFF ('2016-01-01 23:59:59', '2016-01-03');
6	DATE ADD() Agrega o resta cualquier unidad de tiempo a / de la fecha y hora. Example - SELECCIONAR FECHA_ADD ('2016-01-04 23:59:59', INTERVALO 22 SEGUNDOS);
7	EXTRACT() Extrae una unidad de la fecha. Example - SELECCIONAR EXTRACTO (AÑO DESDE '2016-01-08');
8	NOW() Devuelve la fecha y hora actuales en formato aaaa-mm-dd hh: mm: ss o aaaammddhhmmss.uuuuuu. Example - SELECCIONAR AHORA ();
9	DATE FORMAT() Formatea la fecha de acuerdo con la cadena de formato especificada. Example - SELECCIONAR FECHA_FORMATO ('2016-01-09 20:20:00', '% W% M% Y');

A continuación se presentan algunas funciones de tiempo importantes:

No Señor	Nombre y descripción
1	HOUR() Devuelve la hora del tiempo o las horas transcurridas. Example - SELECCIONAR HORA ('19: 17: 09 ');
2	LOCALTIME() Funciona exactamente como NOW ().
3	MICROSECOND() Devuelve los microsegundos del tiempo. Example - SELECCIONAR MICROSECONDO ('16: 30: 00.543876 ');
4	MINUTE() Devuelve los minutos del tiempo. Example - SELECCIONAR MINUTO ('2016-05-22 17:22:01');
5	SECOND() Devuelve los segundos de la fecha. Example - SELECCIONAR SEGUNDO ('2016-03-12 16: 30: 04.000001');
6	TIME_FORMAT() Formatea la hora de acuerdo con la cadena de formato especificada. Example - SELECT TIME_FORMAT ('22: 02: 20 ','% H% k% h% I% l ');
7	TIMESTAMP() Proporciona una marca de tiempo para una actividad en el formato aaaa-mm-dd hh: mm: dd. Example - CREAR TABLA orders_ (ID INT, tmst TIMESTAMP);

Funciones numéricas de MariaDB

A continuación se muestran algunas funciones numéricas importantes en MariaDB:

No Señor	Nombre y descripción
1	TRUNCATE() Devuelve un número truncado a la especificación de lugar decimal. Example - SELECCIONAR TRUNCATE (101.222, 1);
2	COS() Devuelve el coseno de x radianes. Example - SELECCIONAR COS (PI ());
3	CEILING() Devuelve el número entero más pequeño que no sea inferior a x. Example - SELECCIONAR TECHO (2.11);
4	DEGREES() Convierte radianes a grados. Example - SELECCIONAR GRADOS (PI ());
5	DIV() Realiza división de enteros. Example - SELECCIONAR 100 DIV 4;
6	EXP() Devuelve e a la potencia de x. Example - SELECCIONAR EXP (2);
7	FLOOR() Devuelve el entero más grande que no esté por encima de x. Example - SELECCIONAR PISO (2.01);
8	LN() Devuelve el logaritmo natural de x. Example - SELECCIONAR LN (3);
9	LOG() Devuelve el logaritmo natural o el logaritmo a una base determinada. Example - SELECCIONAR REGISTRO (3);
10	SQRT() Devuelve la raíz cuadrada. Example - SELECCIONAR SQRT (16);

Funciones de cadena MariaDB

Las funciones de cadena importantes se dan a continuación:

No Señor	Nombre y descripción
1	INSTR() Devuelve la posición de la primera instancia de una subcadena. Example - SELECCIONAR INSTR ('rambutan', 'tan');
2	RIGHT() Devuelve los caracteres de cadena más a la derecha. Example - SELECCIONAR DERECHA ('rambután', 3);
3	LENGTH() Devuelve la longitud en bytes de una cadena. Example - SELECCIONAR LONGITUD ('rambután');
4	LOCATE() Devuelve la posición de la primera instancia de una subcadena. Example - SELECCIONAR UBICACIÓN ('tan', 'rambután');
5	INSERT() Devuelve una cadena, con una subcadena especificada en una posición determinada, que fue modificada. Example - SELECCIONAR INSERTAR ('ramputan', 4, 1, 'b');
6	LEFT() Devuelve los caracteres más a la izquierda. Example - SELECCIONAR IZQUIERDA ('rambután', 3);
7	UPPER() Cambia los caracteres a mayúsculas. Example - SELECCIONAR SUPERIOR (apellido);
8	LOWER() Cambia los caracteres a minúsculas. Example - SELECCIONAR INFERIOR (apellido);
9	STRCMP() Compara cadenas y devuelve 0 cuando son iguales. Example - SELECCIONE STRCMP ('huevo', 'queso');
10	REPLACE() Devuelve una cadena después de reemplazar caracteres. Example - SELECCIONAR REEMPLAZAR ('ensuciar', 'l', 'n');
11	REVERSE() Invierte caracteres en una cadena. Example - SELECT REVERSE ('coche de carreras');
12	REPEAT() Devuelve una cadena que se repite x veces los caracteres dados. Example - SELECCIONAR REPETIR ('ha', 10);
13	SUBSTRING() Devuelve una subcadena de una cadena, comenzando en la posición x. Example - SELECCIONAR SUBSTRING ('rambután', 3);
14	TRIM() Elimina los caracteres iniciales / finales de una cadena. Example - SELECCIONAR TRIM (LIDERANDO '_' DESDE '_rambutan');