MariaDB PDF

Contenido
MariaDB - Inicio
MariaDB - Introducción
MariaDB - Instalación
MariaDB - Administración
MariaDB - Sintaxis PHP
MariaDB - Conexión
MariaDB - Crear base de datos
MariaDB - Drop Database
MariaDB - Seleccionar base de datos
MariaDB - Tipos de datos
MariaDB - Crear tablas
MariaDB - Tablas desplegables
MariaDB - Insertar consulta
MariaDB - Seleccionar consulta
MariaDB - Donde cláusula
MariaDB - Consulta de actualización
MariaDB - Eliminar consulta
MariaDB - Cláusula Like
MariaDB - Ordenar por cláusula
MariaDB - Únete
MariaDB - Valores nulos
MariaDB - Expresión regular
MariaDB - Transacciones
MariaDB - Alter Command
Tablas de índices y estadísticas
MariaDB - Tablas temporales
MariaDB - Clonación de tablas
MariaDB - Secuencias
MariaDB - Gestión de duplicados
MariaDB - Protección de inyección SQL
MariaDB - Métodos de respaldo
MariaDB - Métodos de carga de respaldo
MariaDB - Funciones útiles
MariaDB - Introducción
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 usan fuentes de datos no relacionales, como
objetos o archivos. Sin embargo, las bases de datos son la mejor opción para
grandes conjuntos de datos, que sufrirían una recuperación y escritura lentas
con otras fuentes de datos.
Los sistemas de gestió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.
 Aseguran la integridad de las referencias a través de filas de varias tablas.
 Actualizan automáticamente los índices.
 Interpretan las consultas y operaciones de SQL al manipular u 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.
 Base de datos : una base de datos es una fuente de datos que consta de tablas
que contienen datos relacionados.
 Tabla : una tabla, que significa una hoja de cálculo, es una matriz que contiene
datos.
 Columna : una columna, que significa elemento de datos, es una estructura que
contiene datos de un tipo; por ejemplo, fechas de envío.
 Fila : una fila es una estructura que agrupa datos relacionados; por ejemplo, datos
para un cliente. También se conoce como tupla, entrada o registro.
 Redundancia : este término se refiere al almacenamiento de datos dos veces
para acelerar el sistema.
 Clave primaria : se refiere a un valor de identificación único. Este valor no puede
aparecer dos veces dentro de una tabla, y solo hay una fila asociada.
 Clave externa : una clave externa sirve como enlace entre dos tablas.
 Clave compuesta : una clave compuesta, o clave compuesta, es una clave que
se refiere a varias columnas. Se refiere a múltiples columnas debido a una
columna que carece de una calidad única.
 Índice : un índice es prácticamente idéntico al índice de un libro.
 Integridad referencial : este término se refiere a garantizar que todos los valores
de clave externa apunten a filas existentes.
MariaDB Database
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 para pequeñas
tareas de procesamiento de datos y necesidades empresariales. Su objetivo
es ser un reemplazo directo para 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 la tecnología de clúster Galera.
 MariaDB también ofrece muchas operaciones y comandos no disponibles en
MySQL, y elimina / reemplaza características que afectan negativamente el
rendimiento.
Empezando
Antes de comenzar este tutorial, asegúrese de tener algunos conocimientos

básicos de PHP y HTML, específicamente 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 de gran utilidad para los desarrolladores de PHP.
Recomendamos encarecidamente que revise nuestro Tutorial PHP si no está
familiarizado o necesita revisarlo.
Síguenos en Instagram para que estés al tanto de los

nuevos libros de programación. Click aqui
www.postparaprogramadores.com
/
MariaDB - Instalación
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 desea y se muestra una lista de descargas para
múltiples 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
 menta
 Slackware
Siga estos pasos para instalar en un entorno Ubuntu:
Paso 1 : inicie sesión como usuario root.
Paso 2 : navega hasta el directorio que contiene el paquete MariaDB.
Paso 3 : importe la clave de firma de GnuPG con el siguiente código:
sudo apt-key adv --recv-keys --keyserver keyserver.ubuntu.com
0xcbcb082a1bb943db
Paso 4 : agrega MariaDB al archivo sources.list . 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'
Paso 5 : actualice el sistema con lo siguiente:
sudo apt-get update
Paso 6 - Instala MariaDB con lo siguiente:
sudo apt-get install mariadb-server
Instalando en Windows
Después de localizar y descargar un archivo de instalación automatizada
(MSI), simplemente haga doble clic en el archivo para comenzar 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 a 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 se realiza correctamente, verá mensajes relacionados con el
inicio. Si esto no aparece, puede tener 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 la línea de comando le resulta incómoda o engorrosa, asegúrese
de experimentar con ella.
Probar la instalación
Realice algunas tareas simples para confirmar el funcionamiento y la
instalación de MariaDB.
Use la utilidad de administración para obtener el estado del servidor
Ver 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.
Ejecutar comandos simples con un cliente
Abra el símbolo del sistema para MariaDB. Esto debería conectarlo 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 instalado MySQL en su sistema Windows y desea actualizar a
MariaDB; no desinstale MySQL e instale MariaDB. Esto causará 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 por defecto para archivos
temporales. Si tiene muchos archivos temporales, modifique el tamaño del búfer
de claves si no utiliza las tablas MyISAM.
 Si sus aplicaciones se conectan / desconectan con frecuencia, modifique el
tamaño del 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, hay suficientes

diferencias para crear problemas en la actualización. Revise más de estas
diferencias clave en la Base de conocimiento MariaDB.
MariaDB - Administración
Antes de intentar ejecutar MariaDB, primero determine su estado actual,
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 "stop" con el script.
Si desea iniciarlo automáticamente en Linux, agregue scripts de inicio a
su sistema init . 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 usuario sin privilegios. También tiene
la opción de usar un valor hash para la contraseña. Otorgue privilegios de
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 otorgamiento. Esto permite que se
use 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 coincida con su entorno.
Después de la modificación del archivo, navegue al directorio de origen y
ejecute lo siguiente:
./scripts/mysql_install_db --srcdir = $PWD --datadir =
/path/to/data/dir --
user = $LOGNAME
Omita la variable "$ PWD" si agregó datadir al archivo de
configuración. Asegúrese de utilizar "$ LOGNAME" cuando ejecute la versión
10.0.1 de MariaDB.
Comandos Administrativos
Revise la siguiente lista de comandos importantes que usará regularmente
cuando trabaje con MariaDB:
 USE [nombre de la base de datos] : establece la base de datos predeterminada
actual.
 MOSTRAR BASES DE DATOS : enumera las bases de datos actualmente en el
servidor.
 MOSTRAR TABLAS : enumera todas las tablas no temporales.
 MOSTRAR COLUMNAS DESDE [nombre de tabla] : proporciona información de
columna relativa a la tabla especificada.
 SHOW INDEX FROM TABLENAME [nombre de tabla] : proporciona información
de índice de tabla relacionada con la tabla especificada.
 SHOW TABLE STATUS LIKE [nombre de tabla] \ G - - Proporciona a las tablas
información sobre tablas no temporales, y el patrón que aparece después de la
cláusula LIKE se usa para buscar nombres de tablas.
MariaDB - Sintaxis PHP

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 idiomas 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 usará 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 muestra la sintaxis general de una llamada 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 las funciones de PHP.
MariaDB - Conexión
Una forma de establecer una conexión con MariaDB consiste en utilizar el
binario mysql en el símbolo del sistema.
MYSQL Binary
Revise un ejemplo a continuación.
[root@host]# mysql -u root -p
Enter password:******
El código anterior se conecta a MariaDB y proporciona un símbolo del sistema
para ejecutar comandos SQL. Después de ingresar el código, debe aparecer
un mensaje de bienvenida que indica 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 de MariaDB y realizar operaciones.
Desconéctese de MariaDB a través del comando de salida 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 la función mysql_connect () 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 proporciona la función mysql_close () para
cerrar las conexiones de la base de datos, que utiliza un único 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 Descripción de parámetros
Señor
1
servidor
Este parámetro opcional especifica el nombre de host que ejecuta el servidor de
base de datos. Su valor predeterminado es "localhost: .3036".
2
usuario
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 es en blanco.
44
nuevo_enlace
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.
55
banderas de clientes
Este parámetro opcional utiliza una combinación de los siguientes valores
constantes:
 MYSQL_CLIENT_SSL: utiliza cifrado SSL.
 MYSQL_CLIENT_COMPRESS: utiliza el 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
de segundos de inactividad antes de cerrar la conexión.
Revise la sintaxis del script de desconexión de PHP 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
MariaDB - Crear base de datos
La creación o eliminación de bases de datos en MariaDB requiere privilegios
que generalmente solo se otorgan a los usuarios raíz o administradores. Bajo
estas cuentas, tiene dos opciones para crear una base de datos: el binario
mysqladmin y un script PHP.
binario mysqladmin
El siguiente ejemplo demuestra el uso del binario mysqladmin en la creación
de una base de datos con el nombre Productos :
[root@host]# mysqladmin -u root -p create PRODUCTS
PHP Crear script de base de datos

PHP emplea la función mysql_query para crear una base de datos
MariaDB. La función utiliza dos parámetros, uno opcional, y devuelve un valor
de "verdadero" cuando tiene éxito o "falso" cuando no lo es.
Sintaxis
Revise la siguiente sintaxis de script de creación de base de datos :

bool mysql_query( sql, connection );
S.No Descripción de parámetros
1
sql
Este parámetro requerido consiste en la consulta SQL necesaria para realizar la
operación.
2
conexión
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
$dbuser = 'root';
$dbpass = 'rootpassword';
if(! $conn ) {
}
echo 'Connected successfully ';

$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>
En la eliminación exitosa, verá el siguiente resultado:

mysql> Database PRODUCTS created successfully
mysql> SHOW DATABASES;
+-----------------------+
| Database |
+-----------------------+
| PRODUCTS |
+-----------------------+
MariaDB - Drop Database
La creación o eliminación de bases de datos en MariaDB requiere privilegios,
por lo general, solo otorgados a usuarios o administradores raíz. Bajo 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, por lo
tanto, tenga cuidado al realizar esta operación. Además, los scripts PHP
utilizados para la eliminación no le solicitan una confirmación antes de la
eliminación.
binario mysqladmin
El siguiente ejemplo muestra cómo usar el binario mysqladmin para eliminar
una base de datos existente:
[root@host]# mysqladmin -u root -p drop PRODUCTS
mysql> DROP PRODUCTS
ERROR 1008 (HY000): Can't drop database 'PRODUCTS'; database
doesn't exist
PHP Drop Script de base de datos

PHP emplea la función mysql_query para eliminar bases de datos
MariaDB. La función utiliza dos parámetros, uno opcional, y devuelve un valor
de "verdadero" cuando tiene éxito o "falso" cuando no lo es.
Sintaxis
Revise la siguiente sintaxis de script de base de datos de caída:

bool mysql_query( sql, connection );
No Descripción de parámetros
Señor
1
sql
Este parámetro requerido consiste en la consulta SQL necesaria para realizar la
operación.
2
conexión
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
$dbuser = 'root';
if(! $conn ) {
}
$sql = 'DROP DATABASE PRODUCTS';
if(! $retval ){
die('Could not delete database: ' .
mysql_error());
}
echo "Database PRODUCTS deleted successfully\n";

mysql_close($conn);
?>
</body>
</html>
En la eliminación exitosa, verá el siguiente resultado:

mysql> Database PRODUCTS deleted successfully
MariaDB - Seleccionar base de datos
Después de conectarse a MariaDB, debe seleccionar una base de datos para
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
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.
Nota : Todos los nombres (p. Ej., Base de datos, tabla, campos) distinguen
entre mayúsculas y minúsculas. Asegúrese de que los comandos se ajusten al
caso apropiado.
PHP Seleccionar script de base de datos

PHP proporciona la función mysql_select_db para la selección de bases de
datos. La función utiliza dos parámetros, uno opcional, y devuelve un valor de
"verdadero" en la selección exitosa, o falso en caso de falla.
Sintaxis
Revise la siguiente sintaxis de script de base de datos select.

bool mysql_select_db( db_name, connection );
S.No Descripción de parámetros
1
db_name
Este parámetro requerido especifica el nombre de la base de datos a utilizar.
2
conexión
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
$dbuser = 'guest1';
$dbpass = 'guest1a';
if(! $conn ) {
}
echo 'Connected successfully';
mysql_select_db( 'PRODUCTS' );
mysql_close($conn);
?>
</body>
</html>
En una selección exitosa, verá el siguiente resultado:
mysql> Connected successfully
MariaDB - Tipos de datos
Las buenas definiciones de campo son esenciales para la optimización de su
base de datos. El enfoque ideal requiere que use exclusivamente un campo
del tipo y tamaño necesarios. Por ejemplo, si solo usará 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 dados
los tipos de datos almacenados dentro del campo.
Los tipos de datos de MariaDB se pueden clasificar como numéricos, de fecha
y hora y valores 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 enteros pequeños 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 "false" y un valor 1 con
"true".
 SMALLINT : este tipo de datos representa 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 enteros en el rango con signo de -
8388608 a 8388607, y el rango sin signo de 0 a 16777215.
 INT (también INTEGER) : este tipo de datos representa un número entero de
tamaño normal. Cuando se marca como sin signo, 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 a ceros para colocar M
dígitos en el valor INT.
 BIGINT : este tipo de datos representa enteros dentro del rango con signo de
9223372036854775808 a 9223372036854775807, y el rango sin signo de 0 a
18446744073709551615.
 DECIMAL (también DEC, NUMERIC, FIJO): este tipo de datos representa
números precisos de punto fijo, con M especificando sus dígitos y D especificando
los dígitos después del decimal. El valor M no agrega "-" o el punto decimal. Si D
se establece en 0, no aparece ninguna parte decimal o fracción y el valor se
redondeará al DECIMAL más cercano al INSERTAR. Los dígitos máximos
permitidos son 65, y el máximo para 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 coma flotante del
valor 0 o un número dentro de los siguientes rangos:
o -3.402823466E + 38 a -1.175494351E-38
o 1.175494351E-38 a 3.402823466E + 38
 DOBLE (también REAL y DOBLE PRECISIÓN) : este tipo de datos representa
números de coma flotante de tamaño normal del valor 0 o dentro de los siguientes
rangos:
o -1.7976931348623157E + 308 a -2.2250738585072014E-308
o 2.2250738585072014E-308 a 1.7976931348623157E + 308
 BIT : este tipo de datos representa campos de bits con M que especifica el número
de bits por valor. Al omitir 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 0s y
1s. El relleno cero ocurre automáticamente desde la izquierda para toda la
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:
 FECHA : 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".
 TIEMPO : este tipo de datos representa un rango 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 tiempo de
modificaciones de la base de datos, por ejemplo, inserción o actualización.
 AÑO : 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:
 Literales de cadena : este tipo de datos representa secuencias de caracteres
entre comillas.
 CHAR : este tipo de datos representa una cadena de longitud fija y rellena a la
derecha que contiene espacios de longitud especificada. M representa la longitud
de la 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.
 BINARIO : este tipo de datos representa cadenas de bytes binarios, con M como
la longitud de la columna en bytes.
 VARBINARIO : 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 blob 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 blob 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 blob con una
longitud máxima de 16.777.215 (22 4 - 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 blob con una longitud
máxima de 4,294,967,295 (2 32 - 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 8 - 1) caracteres. En el almacenamiento, cada uno usa un
prefijo de longitud de un byte que indica la cantidad de bytes en el valor.
 TEXTO : este tipo de datos representa una columna de texto con una longitud
máxima de 65.535 (2 16 - 1) caracteres. En el almacenamiento, cada uno usa un
prefijo de longitud de dos bytes que indica la cantidad de bytes en el valor.
 MEDIO TEXTO : este tipo de datos representa una columna de texto con una
longitud máxima de 16.777.215 (2 24 - 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 4 GB (2 32 - 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.
MariaDB - Crear tablas

En este capítulo, aprenderemos cómo crear tablas. Antes de crear una tabla,
primero determine su nombre, nombres de campo y definiciones de campo.
La siguiente es la sintaxis general para la creación de tablas:
CREATE TABLE table_name (column_name column_type);
Revise el comando aplicado a la creación de 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 utiliza "NOT NULL" como atributo de campo para evitar
errores causados por un valor nulo. El atributo "AUTO_INCREMENT" le indica
a MariaDB que agregue el siguiente valor disponible al campo ID. La clave
principal de la palabra clave define una columna como la clave
principal . Múltiples columnas separadas por comas pueden definir una clave
primaria.
Los dos métodos principales para crear tablas están utilizando el símbolo del
sistema y un script PHP.
Utilice el comando CREATE TABLE para realizar la tarea como se muestra a
continuación:
root@host# mysql -u root -p
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.
PHP Crear script de 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
$dbuser = 'root';
if(! $conn ){
}
$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 )); ";
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
MariaDB - Tablas desplegables
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: usar el símbolo del
sistema o un script PHP.

En el símbolo del sistema, simplemente use el comando DROP TABLE SQL -
root@host# mysql -u root -p
Database changed
mysql> DROP TABLE products_tbl
mysql> SELECT * from products_tbl

ERROR 1146 (42S02): Table 'products_tbl' doesn't exist
PHP Drop Table Script

PHP proporciona mysql_query () para soltar tablas. Simplemente pase su
segundo argumento el comando SQL apropiado:
<html>
<head>
<title>Create a MariaDB Table</title>
</head>
<body>
<?php
$dbuser = 'root';
if(! $conn ) {
}
$sql = "DROP TABLE products_tbl";

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
MariaDB - Insertar consulta
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, seguida 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 valores de
cadena. Otras opciones para la declaración incluyen declaraciones "INSERT
... SET", declaraciones "INSERT ... SELECT" y varias otras opciones.
Nota : La función VALUES () que aparece dentro de la instrucción, solo se
aplica a las instrucciones 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.

En el indicador, hay muchas formas de realizar una operación de selección. A
continuación se presenta 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 "INSERTAR EN ..." dentro de una función PHP
para realizar la operación. Utilizará la función mysql_query () una vez más.
Revise el ejemplo que figura a continuación:
<?php
if(isset($_POST['add'])) {
$dbuser = 'root';
if(! $conn ) {
}
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_dat
e')";
mysql_select_db('PRODUCTS');
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á en las 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.
MariaDB - Seleccionar consulta

En este capítulo, aprenderemos cómo seleccionar datos de una tabla.
Las instrucciones SELECT recuperan las filas seleccionadas. Pueden incluir
sentencias UNION, una cláusula de orden, 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
 nombre_tabla.nombre_columna
 database_name.table_name.column_name
Todas las declaraciones select deben contener una o más expresiones
select . Las expresiones de selección consisten en una de las siguientes
opciones:
 Un nombre de columna.
 Una expresión que emplea operadores y funciones.
 La especificación "nombre_tabla. *" 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.
El símbolo del sistema o un script PHP se pueden emplear para ejecutar una
instrucción select.
En el símbolo del sistema, ejecute las declaraciones de la siguiente manera:
root@host# mysql -u root -p password;
Database changed
+-------------+---------------+
| ID_number | Nomenclature |
+-------------+---------------+
| 12345 | Orbitron 4000 |
+-------------+---------------+
PHP Seleccione Script

Emplee las mismas declaraciones SELECT dentro de una función PHP para
realizar la operación. Utilizará la función mysql_query () una vez más. Revise
un ejemplo a continuación:
<?php
$dbuser = 'root';
if(! $conn ) {
}
$sql = 'SELECT product_id,

product_name,product_manufacturer, ship_date FROM
products_tbl';
if(! $retval ) {
die('Could not get data: ' . mysql_error());
}
while($row = mysql_fetch_array($retval, MYSQL_ASSOC)) {

echo "Product ID :{$row['product_id']} ".
"Name: {$row['product_name']} ".
"Manufacturer: {$row['product_manufacturer']} 
".
"Ship Date : {$row['ship_date']} ".
"-------------------------------- ";
}
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
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 la función mysql_free_result () para
este propósito. Revise su uso como se muestra a continuación:
<?php
$dbuser = 'root';
if(! $conn ) {
}
$sql = 'SELECT product_id, product_name,

product_manufacturer, ship_date FROM products_tbl';
if(! $retval ) {
}
while($row = mysql_fetch_array($retval, MYSQL_NUM)) {

echo "Product ID :{$row[0]} ".
"Name: {$row[1]} ".
"Manufacturer: {$row[2]} ".
"Ship Date : {$row[3]} ".
"-------------------------------- ";
}
mysql_free_result($retval);
mysql_close($conn);
?>
MariaDB - Donde cláusula

Las cláusulas WHERE 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 que figura 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 que se especifique 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.

En el símbolo del sistema, simplemente use un comando estándar:
Database changed
mysql> SELECT * from products_tbl WHERE product_manufacturer
= 'XYZ Corp';
+-------------+----------------+----------------------+
| ID_number | Nomenclature | product_manufacturer |
+-------------+----------------+----------------------+
| 12345 | Orbitron 4000 | XYZ Corp |
+-------------+----------------+----------------------+
+-------------+----------------+----------------------+
+-------------+----------------+----------------------+
Revise un ejemplo usando la condición AND -
SELECT *
FROM products_tbl
WHERE product_name = 'Bun Janshu 3000';
AND product_id <= 344;
Este ejemplo combina 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 que usan la cláusula Where

Emplea la función mysql_query () en operaciones usando una cláusula
WHERE -
<?php
$dbuser = 'root';
if(! $conn ) {
}

product_manufacturer, ship_date
FROM products_tbl
WHERE product_manufacturer = "XYZ Corp"';
if(! $retval ) {
}

".
"Ship Date: {$row['ship_date']} ".
"-------------------------------- ";
}

mysql_close($conn);
?>

Product ID: 12345
Ship Date: 01/01/17
----------------------------------------------
Product ID: 12346
Ship Date: 01/02/17
----------------------------------------------
Product ID: 12347
Ship Date: 01/02/17
----------------------------------------------
MariaDB - Consulta de actualización
El comando ACTUALIZAR modifica los campos existentes cambiando los
valores. Utiliza la cláusula SET para especificar columnas para su
modificación 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 ACTUALIZAR desde el símbolo del sistema o utilizando
un script PHP.

En el símbolo del sistema, simplemente use una raíz de comando estándar:
Database changed
mysql> UPDATE products_tbl
SET nomenclature = 'Fiber Blaster 300Z' WHERE ID_number =
112;
mysql> SELECT * from products_tbl WHERE ID_number='112';
+-------------+---------------------+----------------------+
+-------------+---------------------+----------------------+
| 112 | Fiber Blaster 300Z | XYZ Corp |
+-------------+---------------------+----------------------+
Script de consulta de actualización de PHP
Emplee la función mysql_query () en las instrucciones del comando UPDATE
-
<?php
$dbhost = „localhost:3036‟;
$dbuser = „root‟;
$dbpass = „rootpassword‟;
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‟);
if(! $retval ) {
die(„Could not update data: „ . mysql_error());
}
echo “Updated data successfully\n”;

mysql_close($conn);
?>
En una actualización de datos exitosa, verá el siguiente resultado:
mysql> Updated data successfully
MariaDB - Eliminar consulta
El comando DELETE elimina las filas 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, se
eliminan todas las filas. 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 usando un script
PHP.
root@host# mysql –u root –p password;
Database changed
mysql> DELETE FROM products_tbl WHERE product_id=133;
ERROR 1032 (HY000): Can't find record in 'products_tbl'
PHP Eliminar script de consulta

Use la función mysql_query () en las instrucciones del comando DELETE -
<?php
$dbuser = 'root';
if(! $conn ) {
}
$sql = 'DELETE FROM products_tbl WHERE product_id = 261';

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
ERROR 1032 (HY000): Can't find record in 'products_tbl'
MariaDB - Cláusula Like
La cláusula WHERE proporciona una forma de recuperar datos cuando una
operación utiliza una coincidencia exacta. En situaciones que requieren
múltiples resultados con características compartidas, la cláusula LIKE
se adapta a una amplia coincidencia de patrones.
Una cláusula LIKE prueba una coincidencia de patrón, devolviendo un
verdadero o falso. Los patrones utilizados para la comparación aceptan los
siguientes caracteres comodín: "%", que coincide con el número de caracteres
(0 o más); y "_", que coincide con un solo carácter. El carácter comodín “_”
solo coincide con los 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, por lo que requieren
configuraciones adicionales para la mayúsculas y minúsculas.
Una cláusula NOT LIKE permite probar la condición opuesta, al igual que
el operador no .
Si la expresión o patrón de la declaración se evalúa como NULL, el resultado
es NULL.
Revise la sintaxis general de la cláusula LIKE dada 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.

mysql> use TUTORIALS;
Database changed
WHERE product_manufacturer LIKE 'XYZ%';
+-------------+----------------+----------------------+
+-------------+----------------+----------------------+
+-------------+----------------+----------------------+
+-------------+----------------+----------------------+
+-------------+----------------+----------------------+
Script PHP que usa la cláusula Like

Use la función mysql_query () en declaraciones que empleen la cláusula
LIKE
<?php
$dbuser = 'root';
if(! $conn ) {
}
FROM products_tbl WHERE product_manufacturer LIKE
"xyz%"';
if(! $retval ) {
}

echo "Product ID:{$row['product_id']} ".
".
"Ship Date: {$row['ship_date']} ".
"-------------------------------- ";
}

mysql_close($conn);
?>

Product ID: 12345
Ship Date: 01/01/17
----------------------------------------------
Product ID: 12346
Ship Date: 01/02/17
----------------------------------------------
Product ID: 12347
Ship Date: 01/02/17
----------------------------------------------
MariaDB - Ordenar por cláusula
La cláusula ORDER BY , como se mencionó en discusiones anteriores,
clasifica 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). Al omitir 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 usar un número entero para identificar
una columna.
Revise la sintaxis general de la cláusula ORDER BY dada a continuación:
SELECT field, field2,... [or column] FROM table_name,
table_name2,...
ORDER BY field, field2,... ASC[or DESC]
Use una cláusula ORDER BY en el símbolo del sistema o dentro de un script
PHP.

root@ host# mysql -u root -p password;
Database changed
mysql> SELECT * from products_tbl ORDER BY

product_manufacturer ASC
+-------------+----------------+----------------------+
+-------------+----------------+----------------------+
| 56789 | SuperBlast 400 | LMN Corp |
+-------------+----------------+----------------------+
| 67891 | Zoomzoom 5000 | QFT Corp |
+-------------+----------------+----------------------+
+-------------+----------------+----------------------+
Script PHP que utiliza el orden por cláusula

Utilice la función mysql_query () , una vez más, en las declaraciones que
emplean la cláusula ORDER BY:
<?php
$dbuser = 'root';
if(! $conn ) {
}

FROM products_tbl ORDER BY product_manufacturer DESC';
if(! $retval ) {
}

".
"Ship Date : {$row['ship_date']} ".
"-------------------------------- ";
}

mysql_close($conn);
?>
Product ID: 12347
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
----------------------------------------------
MariaDB - Únete
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 múltiples
tablas.
Las uniones permiten combinar dos o más tablas en un solo objeto. Se
emplean a través de 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 sintaxis anterior para JOINS utilizaba combinaciones
implícitas y ninguna palabra clave. Es posible utilizar una cláusula WHERE
para lograr una unión, pero las palabras clave funcionan mejor para facilitar la
lectura, el mantenimiento y las mejores prácticas.
Las uniones vienen en muchas formas, como una unión izquierda, una unión
derecha o una unión interna. Varios tipos de unión ofrecen diferentes tipos de
agregación basados en valores o características compartidas.
Emplee un JOIN en el símbolo del sistema o con un script PHP.

En el símbolo del sistema, simplemente use una declaración estándar:
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

Use la función mysql_query () para realizar una operación de unión -
<?php
$dbuser = 'root';
if(! $conn ) {
}
$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';
if(! $retval ) {
}

echo "Manufacturer:{$row['product_manufacturer']} 
".
"Count: {$row['product_count']} ".
"Product ID: {$row['product_id']} ".
"-------------------------------- ";
}

mysql_close($conn);
?>

ID Number: 12345
Inventory Count: 150
--------------------------------------
ID Number: 12346
Inventory Count: 200
--------------------------------------
ID Number: 12347
Inventory Count: 0
--------------------------------------
MariaDB - Valores nulos
Cuando trabaje con valores NULL, recuerde que son valores
desconocidos. No son cadenas vacías o 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 falta de información
de registro 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)

 \NORTE
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, no verdadero o falso. Las comparaciones con NULL o
que posiblemente lo contengan deben usar el operador "<=>" (NULL-SAFE).
Otros operadores disponibles son -
 IS NULL: prueba un valor NULL.
 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 NULL de una lista, o devuelve un valor
NULL en ausencia de uno.
Ordenar valores nulos

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;
La otra manera
SELECT column1 FROM product_tbl ORDER BY IF(column1 IS NULL,
0, 1), column1 DESC;
Funciones NULL
Las funciones generalmente generan NULL cuando cualquier parámetro es
NULL. Sin embargo, hay funciones específicamente diseñadas 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; de lo
contrario, 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 NOT 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 su lugar. En las columnas virtuales, un tema
discutido más adelante en este tutorial, se asigna el valor predeterminado.
Los índices ÚNICOS pueden contener muchos valores NULL, sin embargo, las
claves primarias no pueden ser NULL.
Valores NULL y el comando Alter
Cuando utiliza el comando ALTER para modificar una columna, en ausencia

de especificaciones NULL, MariaDB asigna automáticamente valores.
MariaDB - Expresión regular

Más allá de la coincidencia de patrones disponible de las cláusulas LIKE,
MariaDB ofrece coincidencias basadas en expresiones regulares a través del
operador REGEXP. El operador realiza la coincidencia de patrones para una
expresión de cadena basada en un patrón dado.
MariaDB 10.0.5 introdujo las expresiones regulares de PCRE, que aumentan
drásticamente el alcance de la coincidencia en áreas como patrones
recursivos, afirmaciones anticipadas y más.
Revise el uso de la sintaxis estándar del operador REGEXP que figura 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 se crearon por razones de compatibilidad.
El patrón comparado puede ser una cadena literal u otra cosa, como una
columna de tabla. En las cadenas, usa la sintaxis de escape C, por lo que
duplica cualquier carácter "\". REGEXP también 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
PS
Coincide con el final de la cuerda.
3
.
Coincide con un solo personaje.
44
[...]
Coincide con cualquier personaje entre paréntesis.
55
[^ ...]
Coincide con cualquier personaje que no esté entre paréntesis.
66
p1 | p2 | p3
Coincide con cualquiera de los patrones.
77
**
Coincide con 0 o más instancias del elemento anterior.
8
+
Coincide con 1 o más instancias del elemento anterior.
99
{norte}
Coincide con n instancias del elemento anterior.
10
{Minnesota}
Coincide con instancias mn del elemento anterior.
Revise los ejemplos de coincidencia de patrones que se muestran 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]';
MariaDB - Transacciones
Las transacciones son operaciones de grupo secuenciales. Funcionan como
una sola unidad y no terminan hasta que todas las operaciones dentro del
grupo se ejecuten con éxito. Una sola falla en el grupo hace que la transacción
completa falle y que no tenga ningún impacto en la base de datos.
Las transacciones se ajustan a ACID (atomicidad, consistencia, aislamiento y
durabilidad):
 Atomicidad : garantiza el éxito de todas las operaciones al abortar las fallas y
revertir los cambios.
 Consistencia : garantiza que la base de datos aplique los cambios en una
transacción exitosa.
 Aislamiento : permite la operación de transacciones independientes de las
transacciones.
 Durabilidad : garantiza la persistencia de una transacción exitosa en caso de falla
del sistema.
A la cabeza 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.
Nota - Algunas declaraciones causan una confirmación implícita, y también
causan un error cuando se usan dentro de las transacciones. Los ejemplos de
tales declaraciones incluyen, entre otros, CREAR, ALTERAR y BAJAR.
Las transacciones de 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. Una
configuración de 1 obliga a que todas las operaciones se consideren
transacciones exitosas, y una configuración de 0 hace que la persistencia de
los cambios solo ocurra en una declaración COMMIT explícita.
Estructura de una transacción

La estructura general de un extracto de transacción consiste en comenzar con
INICIAR TRANSACCIÓN. El siguiente paso es insertar uno o más comandos /
operaciones, insertar declaraciones que verifiquen si hay errores, insertar
declaraciones ROLLBACK para administrar cualquier error descubierto y
finalmente insertar una declaración COMMIT para aplicar cambios en
operaciones exitosas.
START TRANSACTION;
SELECT name FROM products WHERE manufacturer = 'XYZ Corp';
UPDATE spring_products SET item = name;
COMMIT;
MariaDB - Alter Command
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 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.
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);
Use 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 PRIMERO y DESPUÉS 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 declaración ALTER. Las cláusulas tienen efectos
similares, pero utilizan una sintaxis sustancialmente diferente.
Revise un ejemplo de CAMBIO que figura a continuación:
mysql> ALTER TABLE products_tbl CHANGE discontinued status
CHAR(4);
En una declaración utilizando CHANGE, 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 restricciones predeterminadas
combinándolo con una cláusula DROP:
mysql> ALTER TABLE products_tbl ALTER discontinued DROP
DEFAULT;
Usando 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;
MariaDB - Tablas de índices y estadísticas
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:
 Primario (un registro representa todos los registros)
 Único (un registro representa múltiples registros)
 Llanura
 Texto completo (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, considere qué
columnas se usan con frecuencia en sus consultas. Luego cree uno o
múltiples índices en ellos. Además, vea los índices como esencialmente tablas
de claves primarias.
Aunque los índices aceleran las búsquedas o las instrucciones SELECT,
hacen que las inserciones y las actualizaciones se arrastren debido a la
realización de operaciones tanto en las tablas como en los índices.
Crear un índice
Puede crear un índice a través de una instrucción CREATE TABLE ... INDEX
o una instrucción CREATE INDEX. La mejor opción que admite legibilidad,
mantenimiento y mejores prácticas es CREATE INDEX.
Revise la sintaxis general del índice que figura 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;
Soltar un índice
Puede soltar un índice con DROP INDEX o ALTER TABLE ... DROP. La mejor
opción que admite legibilidad, mantenimiento y mejores prácticas es DROP
INDEX.
Revise la sintaxis general del índice de caída que figura a continuación:
DROP INDEX index_name ON table_name;
DROP INDEX top_sellers ON product_tbl;
Renombrar 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;
ALTER TABLE products_tbl DROP INDEX top_sellers, ADD INDEX
top_2016sellers;
Gestionar índices
Deberá examinar y rastrear todos los índices. Use SHOW INDEX para
enumerar todos los índices existentes asociados con una tabla dada. Puede
establecer el formato del contenido que se muestra mediante el uso de 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 en gran medida 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 del
índice. 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.
MariaDB - Tablas temporales

Algunas operaciones pueden beneficiarse de las tablas temporales debido a la
velocidad o los datos desechables. La vida de una tabla temporal finaliza con
la finalización de una sesión, ya sea que los utilice desde el símbolo del
sistema, con un script PHP o mediante un programa cliente. Tampoco aparece
en el sistema de una manera 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 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 las tablas temporales fantasmas de las sesiones
caducadas.
 A veces entran en conflicto con los nombres en la sombra de las tablas no
temporales.
Nota : 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
usuarios que no sean administradores.
GRANT CREATE TEMPORARY TABLES ON orders TO
'machine122'@'localhost';
Suelta una tabla temporal

Aunque las tablas temporales se eliminan esencialmente al final de las
sesiones, tiene la opción de eliminarlas. La eliminación de una tabla temporal
requiere el uso de la palabra clave TEMPORAL, y las mejores prácticas
sugieren que se eliminen las tablas temporales antes que las no temporales.
mysql> DROP TABLE order;
MariaDB - Clonación de tablas
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 generar una instrucción CREATE TABLE que
detalle toda la estructura de la tabla fuente.
 Edite la declaración para darle un nuevo nombre a la tabla y ejecútela.
 Use una instrucción INSERT INTO ... SELECT si también necesita copiar 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 utiliza 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 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;
MariaDB - Secuencias
En la versión 10.0.3, MariaDB introdujo un motor de almacenamiento conocido
como secuencia. Su ad hoc genera una secuencia de números enteros para
las operaciones, y luego termina. La secuencia contiene enteros positivos en
orden descendente o ascendente, y utiliza 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 el 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 la instalación del 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 la 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 use el atributo AUTO_INCREMENT para definir una columna
como incremento automático.
 Use una base de datos existente y use una consulta SELECT de secuencia para
producir una secuencia. La consulta utiliza seq_ [FROM] _to_ [TO] o seq_ [FROM]
_to_ [TO] _step_STEP sintaxis.
Las mejores prácticas prefieren el uso del segundo método. Revise un ejemplo
de una creación de secuencia 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;
 Construir 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 los sistemas
de reserva.
 Construir una secuencia de tiempo.
MariaDB - Gestión de duplicados

MariaDB, como se discutió en lecciones anteriores, permite registros y tablas
duplicados en algunas situaciones. De hecho, algunos de estos duplicados no
son duplicados debido a distintos tipos de datos u objetos, o como resultado
de una vida útil única o almacenamiento del objeto de operación. Estos
duplicados tampoco suelen presentar 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, buscar duplicados, eliminar
duplicados y evitar la creación de duplicados.
Estrategias y herramientas
Hay cuatro formas clave de administrar duplicados:
 Pesque para ellos con JOIN y elimínelos con una tabla temporal.
 Use INSERT ... ON DUPLICATE KEY UPDATE para actualizar sobre el
descubrimiento de un duplicado.
 Use DISTINCT para podar los resultados de una instrucción SELECT y eliminar
duplicados.
 Use INSERT IGNORE para detener la inserción de duplicados.
Uso de Unirse con una tabla temporal
Simplemente realice una semiunió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 primaria 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 en la inserción en un campo poblado:
INSERT INTO add_dupl VALUES (1,'Apple');
ERROR 1062 (23000): Duplicate entry '1' for key 'PRIMARY'
Nota : 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 duplicados de los resultados. La sintaxis
general para una cláusula DISTINCT es la siguiente:
SELECT DISTINCT fields
FROM table
[WHERE conditions];
Nota - Los resultados de una declaración con una cláusula DISTINCT -
 Cuando se usa una expresión, devuelve valores únicos para ella.
 Cuando se usan 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 indica a MariaDB que cancele la inserción al
descubrir un registro duplicado. Revise un ejemplo de su uso dado 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 en función de la naturaleza de los datos de esa
tabla. Acomode esa necesidad en su estrategia para administrar registros
duplicados.
MariaDB - Protección de inyección SQL

El simple acto 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 en
usuarios que ingresan datos como un nombre, y la lógica del código no puede
analizar esta entrada. El Código, en cambio, permite que un atacante inserte
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 fuerte validación antes de cualquier procesamiento. Realice
esta validación a través de 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 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 de entrada necesarios, tales
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.
 Controlar la sintaxis de los datos ingresados. No permita nada fuera del patrón
necesario.
 Controlar los términos permitidos. Lista negra de palabras clave SQL.
Es posible que no conozca los peligros de los ataques de inyección o que los
considere insignificantes, pero encabezan la lista de problemas de
seguridad. Además, considere el efecto de estas dos entradas:
1=1
-or-
*
El código que permite ingresar cualquiera de los dos junto con el comando
correcto puede dar como resultado que se revelen todos los datos del usuario
en la base de datos o que se eliminen todos los datos en la base de datos, y
ninguna inyección es particularmente inteligente. En algunos casos, los
atacantes ni siquiera pasan tiempo examinando agujeros; Realizan ataques
ciegos con una entrada simple.
Además, considere la coincidencia de patrones y las herramientas de
expresión regular proporcionadas por cualquier lenguaje de programación /
scripting emparejado con MariaDB, que proporcionan más control y, a veces,
un mejor control.
MariaDB - Métodos de respaldo

Los datos sirven como la base de los negocios y las operaciones, y con varias
amenazas posibles (por ejemplo, atacantes, fallas del sistema, actualizaciones
incorrectas y errores de mantenimiento), las copias de seguridad siguen
siendo críticas. Estas copias de seguridad toman 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 para 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 opciones principales para las copias de seguridad incluyen copias de

seguridad lógicas y copias de seguridad físicas. Las copias de seguridad
lógicas contienen instrucciones SQL para restaurar datos. Las copias de
seguridad físicas contienen copias de datos.
 Las copias de seguridad lógicas ofrecen 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 al mismo tipo de máquina y base de datos. Las
copias de seguridad lógicas se producen a nivel de base de datos y tabla, y las
físicas se producen a nivel de directorio y archivo.
 Las copias de seguridad físicas son más pequeñas que las lógicas y también
requieren menos tiempo para realizar y restaurar. 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 herramienta principal utilizada para las copias de seguridad de MariaDB
es mysqldump . Ofrece copias de seguridad lógicas y flexibilidad. También es
una excelente opción para bases de datos pequeñas. Mysqldump
volca datos en SQL, CSV, XML y muchos otros formatos. Su salida no retiene
procedimientos almacenados, vistas y eventos sin instrucciones explícitas.
Hay tres opciones para las copias de seguridad de mysqldump :
 Datos sin procesar : 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
 Exportación de datos / definiciones : esta opción permite exportar una o varias
tablas a un archivo y admite la copia de seguridad de todas las bases de datos
existentes en la máquina host. Examine un ejemplo de exportación de contenidos
o definiciones a un archivo
$ mysqldump -u root -p PRODUCTS products_tbl >
export_file.txt
 Transferencia : 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 opción simple genera la tabla en un archivo de texto
formateado simple:
mysql> SELECT * FROM products_tbl
-> INTO OUTFILE '/tmp/products.txt';
Sus atributos permiten formatear el archivo a sus especificaciones preferidas.
Tenga en cuenta las siguientes cualidades de esta declaración:
 El nombre del archivo debe especificar su ubicación deseada para la salida.
 Necesita privilegios de archivo MariaDB para ejecutar la declaración.
 El nombre del archivo de salida debe ser único.
 Necesita credenciales de inicio de sesión en el host.
 En un entorno UNIX, el archivo de salida es legible en todo el mundo, pero la
propiedad de su servidor afecta su capacidad de eliminarlo. Asegúrate de tener
privilegios.
Usar 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.
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 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.
 Instantáneas : algunos sistemas de archivos permiten instantáneas. El proceso
consiste en enjuagar 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 vacía las cachés en el disco. Luego obtiene una instantánea y
desbloquea las tablas. Consulte el sitio web oficial mylvmbackup 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 INNODB
InnoDB utiliza un grupo de búferes para mejorar el rendimiento. En una copia

de seguridad, configure InnoDB para evitar copiar una tabla completa en el
grupo de búferes porque las copias de seguridad lógicas suelen realizar
escaneos completos de la tabla.
MariaDB - Métodos de carga de respaldo

En este capítulo, aprenderemos sobre varios métodos de carga de
respaldo. Restaurar una base de datos desde una copia de seguridad es un
proceso simple y a veces terriblemente largo.
Hay tres opciones para cargar datos: la declaración LOAD DATA, mysqlimport
y una restauración simple de mysqldump.
Usando CARGAR DATOS

La instrucción 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 consiste en líneas terminadas por avances
de línea (líneas nuevas) y valores de datos separados por tabulaciones.
 Use la cláusula FIELDS para especificar explícitamente el formato de los campos
en una línea. Use la cláusula LINES para especificar el final de línea. Revise un
ejemplo a continuación.
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:
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
Use la opción - columnas para especificar el orden de las columnas -
$ mysqlimport -u root -p --local --columns=c,b,a \
database_name source_file.txt
Usando MYSQLDUMP
Restaurar 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
CARACTERES ESPECIALES Y COTIZACIONES
En una declaración LOAD DATA, las comillas y los caracteres especiales

pueden no interpretarse correctamente. La declaración asume valores sin
comillas y trata las barras invertidas como caracteres de escape. Use la
cláusula FIELDS para especificar el formato. Señale las comillas con
"ENCLOSED BY", lo que provoca la eliminación de comillas de los valores de
datos. Cambie los escapes con "ESCAPED BY".
MariaDB - Funciones útiles

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

Las funciones agregadas más utilizadas se dan a continuación:
No Nombre y descripción
Señor
1
CONTAR
Cuenta el número de registros.
Ejemplo : SELECT COUNT (*) FROM customer_table;
2
MIN
Revela el valor mínimo de un conjunto de registros.
Ejemplo : SELECCIONAR organización, MIN (cuenta) DESDE contratos GRUPO
POR organización;
3
MAX
Revela el valor máximo de un conjunto de registros.
Ejemplo : SELECCIONAR organización, MAX (cuenta_tamaño) DESDE
contratos GRUPO POR organización;
44
AVG
Calcula el valor promedio de un conjunto de registros.
Ejemplo : SELECCIONE AVG (account_size) FROM contratos;
55
SUMA
Calcula la suma de un conjunto de registros.
Ejemplo : SELECCIONAR SUMA (cuenta_tamaño) DE contratos;
MariaDB Cálculo de edad

La función TIMESTAMPDIFF 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 cuerdas MariaDB

La función CONCAT devuelve la cadena resultante después de una operación
de concatenación. Puede utilizar uno o más argumentos. Revise su sintaxis a
continuación:
SELECT CONCAT(item, item,...);
SELECT CONCAT('Ram', 'bu', 'tan');
Output:Rambutan
Funciones de fecha / hora MariaDB

A continuación se presentan funciones de fecha importantes:
Señor
1
CURDATE ()
Devuelve la fecha en formato aaaa-mm-dd o aaaammdd.
Ejemplo : SELECCIONAR CURDATE ();
2
FECHA()
Devuelve la fecha en múltiples formatos.
Ejemplo −CREATE TABLE product_release_tbl (x DATE);
3
CURTIME ()
Devuelve la hora en formato HH: MM: SS o HHMMSS.uuuuuu.
Ejemplo : SELECCIONAR CURTIME ();
44
DATE_SUB ()
Agrega o resta un número de días desde la fecha especificada.
Ejemplo : SELECT DATE_SUB ('2016-02-08', INTERVAL 60 DAY);
55
DATEDIFF ()
Determina los días entre dos fechas.
Ejemplo : SELECT DATEDIFF ('2016-01-01 23:59:59', '2016-01-03');
66
FECHA AGREGAR ()
Agrega o resta cualquier unidad de tiempo a / desde la fecha y la hora.
Ejemplo : SELECT DATE_ADD ('2016-01-04 23:59:59', INTERVAL 22
SECOND);
77
EXTRAER()
Extrae una unidad de la fecha.
Ejemplo : SELECCIONE EXTRACTO (AÑO DE '2016-01-08');
8
AHORA()
Devuelve la fecha y hora actuales en formato aaaa-mm-dd hh: mm: ss o
aaaammddhhmmss.uuuuuu.
Ejemplo : SELECCIONAR AHORA ();
99
FORMATO DE FECHA()
Formatea la fecha de acuerdo con la cadena de formato especificada.
Ejemplo : SELECT DATE_FORMAT ('2016-01-09 20:20:00', '% W% M% Y');
Las siguientes son algunas funciones de tiempo importantes:
Señor
1
HORA()
Devuelve la hora del tiempo o las horas transcurridas.
Ejemplo : SELECCIONAR HORA ('19: 17: 09 ');
2
HORA LOCAL()
Funciona exactamente como NOW ().
3
MICROSEGUNDO()
Devuelve los microsegundos de la época.
Ejemplo : SELECCIONAR MICROSECOND ('16: 30: 00.543876 ');
44
MINUTO()
Devuelve los minutos del tiempo.
Ejemplo : SELECCIONAR MINUTO ('2016-05-22 17:22:01');
55
SEGUNDO()
Devuelve los segundos de la fecha.
Ejemplo : SELECCIONAR SEGUNDO ('2016-03-12 16: 30: 04.000001');
66
FORMATO DE TIEMPO()
Formatea el tiempo de acuerdo con la cadena de formato especificada.
Ejemplo : SELECT TIME_FORMAT ('22: 02: 20 ','% H% k% h% I% l ');
77
TIMESTAMP ()
Proporciona una marca de tiempo para una actividad en el formato aaaa-mm-dd
hh: mm: dd.
Ejemplo : CREATE TABLE orders_ (ID INT, tmst TIMESTAMP);
MariaDB Funciones numéricas

A continuación se presentan algunas funciones numéricas importantes en
MariaDB:
No Señor Nombre y descripción
1
TRUNCAR()
Devuelve un número truncado a la especificación de lugar decimal.
Ejemplo : SELECCIONE TRUNCADO (101.222, 1);
2
COS ()
Devuelve el coseno de x radianes.
Ejemplo : SELECT COS (PI ());
3
TECHO()
Devuelve el entero más pequeño que no está debajo de x.
Ejemplo : SELECCIÓN DE TECHO (2.11);
44
GRADOS ()
Convierte radianes a grados.
Ejemplo : SELECCIONAR GRADOS (PI ());
55
DIV ()
Realiza división entera.
Ejemplo : SELECCIONE 100 DIV 4;
66
EXP()
Devuelve e al poder de x.
Ejemplo : SELECT EXP (2);
77
PISO()
Devuelve el entero más grande que no está por encima de x.
Ejemplo : SELECCIONAR PISO (2.01);
8
LN ()
Devuelve el logaritmo natural de x.
Ejemplo : SELECT LN (3);
99
INICIAR SESIÓN()
Devuelve el logaritmo natural o el logaritmo a una base dada.
Ejemplo : SELECCIONAR REGISTRO (3);
10
SQRT ()
Devuelve la raíz cuadrada.
Ejemplo : SELECT SQRT (16);
Funciones de cadena MariaDB
Las funciones de cadena importantes se dan a continuación:
Señor
1
INSTR ()
Devuelve la posición de la primera instancia de una subcadena.
Ejemplo : SELECT INSTR ('rambutan', 'tan');
2
DERECHA()
Devuelve los caracteres de cadena más a la derecha.
Ejemplo : SELECCIONAR A LA DERECHA ('rambután', 3);
3
LONGITUD()
Devuelve la longitud de bytes de una cadena.
Ejemplo : SELECCIONAR LONGITUD ('rambután');
44
LOCALIZAR()
Devuelve la posición de la primera instancia de una subcadena.
Ejemplo : SELECT LOCATE ('tan', 'rambutan');
55
INSERTAR()
Devuelve una cadena, con una subcadena especificada en una posición
determinada, que se modificó.
Ejemplo : SELECT INSERT ('ramputan', 4, 1, 'b');
66
IZQUIERDA()
Devuelve los caracteres más a la izquierda.
Ejemplo : SELECCIONAR A LA IZQUIERDA ('rambután', 3);
77
SUPERIOR()
Cambia los caracteres a mayúsculas.
Ejemplo : SELECCIONAR SUPERIOR (apellido);
8
INFERIOR()
Cambia los caracteres a minúsculas.
Ejemplo : SELECCIONAR INFERIOR (apellido);
99
STRCMP ()
Compara cadenas y devuelve 0 cuando son iguales.
Ejemplo : SELECT STRCMP ('huevo', 'queso');
10
REEMPLAZAR()
Devuelve una cadena después de reemplazar los caracteres.
Ejemplo : SELECCIONAR REEMPLAZAR ('sully', 'l', 'n');
11
MARCHA ATRÁS()
Invierte los caracteres en una cadena.
Ejemplo : SELECCIONAR REVERSA ('auto de carrera');
12
REPETIR()
Devuelve una cadena que repite caracteres dados x veces.
Ejemplo : SELECT REPEAT ('ha', 10);
13
SUBSTRING ()
Devuelve una subcadena de una cadena, comenzando en la posición x.
Ejemplo : SELECCIONAR SUBSTRING ('rambutan', 3);
14
PODAR()
Elimina los caracteres finales / iniciales de una cadena.
Ejemplo : SELECCIONAR RECORTAR (LEADING '_' FROM '_rambutan');

MariaDB PDF

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

MariaDB PDF

Cargado por

Copyright:

Formatos disponibles

Contenido

Características clave de MariaDB

Las características importantes de MariaDB son:

Antes de comenzar este tutorial, asegúrese de tener algunos conocimientos

Síguenos en Instagram para que estés al tanto de los

Instalación en LINUX / UNIX

 RedHat / CentOS / Fedora

MySQL y MariaDB son esencialmente idénticos. Sin embargo, hay suficientes

 Ejecute mysqld (el binario MariaDB).

Crear una cuenta de usuario

# This will be passed to all mysql clients

# Here is entries for some specific programs

# The MySQL server

# The following three entries caused mysqld 10.0.1-MariaDB

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

# Where you want to have your database

MariaDB - Sintaxis PHP

Script de conexión PHP

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

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

echo 'Connected successfully';

PHP Crear script de base de datos

Revise la siguiente sintaxis de script de creación de base de datos :

S.No Descripción de parámetros

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

echo 'Connected successfully<br />';

echo "Database PRODUCTS created successfully\n";

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

PHP Drop Script de base de datos

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

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

echo "Database PRODUCTS deleted successfully\n";

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

El símbolo del sistema

mysql> use PRODUCTS;

mysql> SELECT database();

PHP Seleccionar script de base de datos

Revise la siguiente sintaxis de script de base de datos select.

S.No Descripción de parámetros

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

Tipos de datos numéricos

Tipos de datos de fecha y hora

MariaDB - Crear tablas

PHP Crear script de tabla

$sql = "CREATE TABLE products_tbl( ".

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

El símbolo del sistema

mysql> SELECT * from products_tbl

PHP Drop Table Script

$sql = "DROP TABLE products_tbl";

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

El símbolo del sistema

Script de inserción PHP

echo "Entered data successfully\n";

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

MariaDB - Seleccionar consulta

PHP Seleccione Script

$sql = 'SELECT product_id,

while($row = mysql_fetch_array($retval, MYSQL_ASSOC)) {

echo "Fetched data successfully\n";

$sql = 'SELECT product_id, product_name,

while($row = mysql_fetch_array($retval, MYSQL_NUM)) {

MariaDB - Donde cláusula