Vista previa del material en texto
UNIVERSIDAD TÉCNICA
LUIS VARGAS TORRES
CAMPUS
ESMERALDAS
UNIDAD ACADÉMICA
INGENIERIA EN TECNOLOGIAS DE LA INFORMACIÓN
TEMA:
QUERY BUILDER EN LARAVEL
CURSO:
5TO A TICS
ESTUDIANTES:
ORTIZ QUIÑONEZ NIXON ALDAIR
PROFESORA:
MINA QUIÑONEZ TERESA
ESMERALDAS, 2022
1. Objetivos.
a. Objetivo General.
• Analizar las diferentes características de trabajo de Query Builder como
herramienta de construcción de base de datos en Laravel mediante la
caracterización de sus diferentes procesos de trabajo, todo esto para un
estudio posterior en cuanto a su uso.
b. Objetivos Específicos.
• Recopilar información relevante sobre el uso de Query Builder en Laravel
• Utilizar diferentes ejemplos para realizar operaciones en Query Builder
usando como base de trabajo Laravel.
2. Introducción.
Query Builder es un constructor de consultas de Base de datos perteneciente a Laravel,
este proporciona una interfaz fluida y conveniente para la creación y ejecución de
consultas de bases de datos. Puede ser usado para ejecutar las principales operaciones
de bases de datos en tu aplicación y funciona en todos los sistemas de bases de datos
soportados. (Laravel, s.f)
De acuerdo a Álvarez (2016), Query Builder contiene una serie de funciones listas para
realizar las operaciones más comunes con una base de datos, pero sin usar el lenguaje
SQL directamente, sino el API de Laravel. Lo que la da la fluidez y facilidad de uso al
momento de utilizar.
Por lo tanto, Query Builder puede trabajar con todos los tipos de bases de datos
soportadas por el Framework de Laravel. Es decir que, el código que nosotros usaremos
se podrá ejecutar para cualquier gestor de base de datos que sea compatible, obteniendo
los mismos resultados. Por tanto, este sistema permite abstraerse del motor de base de
datos que estemos usando por abajo.
Según Laravel (s.f), el constructor de consultas de Laravel usa enlazamiento de
parámetros PDO para proteger tu aplicación contra ataques de inyección SQL. Por lo cual
no hay necesidad de limpiar cadenas que están siendo pasadas como enlaces. El uso de
PDO no admite el enlace de nombres de columna. Por lo tanto, nunca se debe permitir
que la entrada de usuario dicte los nombres de columna a los que hacen referencia las
consultas. Si se debe permitir que el usuario seleccione ciertas columnas para consultar,
hay que validar siempre los nombres de las columnas de la tabla con una lista blanca de
columnas permitidas.
3. Marco Teórico.
3.1. Operaciones en Laravel
3.1.1. Consulta de Datos
• Obtener todas las filas de la tabla
Puedes usar el método table de la clase facade DB para empezar una consulta. El
método table devuelve una instancia para construir consultas fáciles de entender
para la tabla dada, permitiendo que encadenes más restricciones dentro de la
consulta y recibas finalmente los resultados usando el método get:
El método get devuelve una colección de la clase Illuminate\Support\Collection
que contiene los resultados, donde cada resultado es una instancia del objeto
StdClass de PHP. Puedes acceder al valor de cada columna accediendo a la
columna como una propiedad del objeto:
<?php
namespace App\Http\Controllers;
use App\Http\Controllers\Controller;
use Illuminate\Support\Facades\DB;
class UserController extends Controller
{
/**
* Show a list of all of the application's users.
*
* @return Response
*/
public function index()
{
$users = DB::table('users')->get();
return view('user.index', ['users' =>
$users]);
}
}
foreach ($users as $user) {
echo $user->name;
}
• Obtener una sola fila de la tabla/Obtener una sola columna
Si solamente necesitas recuperar una sola fila de la tabla de la base de datos,
puedes usar el método first. Este método devolverá un solo objeto StdClass:
Si no necesitas una fila completa, puedes extraer un solo valor de un registro
usando el método value. Este método devolverá directamente el valor de la
columna:
Para obtener una sola fila por su valor de columna id, usa el método find:
• Obtener una lista de valores de una columna
Si prefieres obtener una Colección que contenga los valores de una sola columna,
puedes usar el método pluck. En el siguiente ejemplo, obtendremos una colección
de títulos de rol:
También puedes especificar una columna clave personalizada para la colección
retornada:
• Especificar una sentencia SELECT
No siempre desearás seleccionar todas las columnas de una tabla de la base de
datos. Usando el método select, puedes especificar una cláusula select
personalizada para la consulta:
$user = DB::table('users')->where('name', 'John')-
>first();
echo $user->name;
$email = DB::table('users')->where('name', 'John')-
>value('email');
$user = DB::table('users')->find(3);
$titles = DB::table('roles')->pluck('title');
foreach ($titles as $title) {
echo $title;
}
$roles = DB::table('roles')->pluck('title', 'name');
foreach ($roles as $name => $title) {
echo $title;
}
El método distinct te permite forzar la consulta para que devuelva solamente
resultados que sean distintos:
Si ya tienes una instancia del constructor de consultas y deseas añadir una
columna a su cláusula select existente, puedes usar el método addSelect:
• Usar operadores where, whereBetween, whereNotBetween, wherIn,
whereNotIn.
La ejecución más básica de where requiere tres argumentos. El primer argumento
es el nombre de la columna. El segundo argumento es un operador, el cual puede
ser cualquiera de los operadores soportados por la base de datos. Finalmente, el
tercer argumento es el valor a evaluar contra la columna. (Palacios, 2020)
Por ejemplo, aquí está una consulta que verifica que el valor de la columna
«votes» sea igual a 100:
Puedes usar otros operadores cuando estés escribiendo una cláusula where:
$users = DB::table('users')->select('name', 'email as
user_email')->get();
$users = DB::table('users')->distinct()->get();
$query = DB::table('users')->select('name');
$users = $query->addSelect('age')->get();
$users = DB::table('users')->where('votes', '=',100)-
>get();
$users = DB::table('users')
->where('votes', '>=', 100)
->get();
$users = DB::table('users')
->where('votes', '<>', 100)
->get();
$users = DB::table('users')
->where('name', 'like', 'T%')
->get();
El método whereBetween verifica que un valor de columna esté en un intervalo
de valores:
El método whereNotBetween verifica que un valor de columna no esté en un
intervalo de valores:
El método whereIn verifica que un valor de una columna dada esté contenido
dentro del arreglo dado:
El método whereNotIn verifica que el valor de una columna dada no esté
contenido en el arreglo dado:
• Sentencia Exists
El método whereExists permite que escribas cláusulas de SQL where exists. El
método whereExists acepta un argumento de tipo Closure, el cual recibirá una
instancia del constructor de consultas permitiendo que definas la consulta que
debería ser puesta dentro de la cláusula «exists»:
La consulta anterior producirá el siguiente SQL:
$users = DB::table('users')
->whereBetween('votes', [1, 100])
->get();
$users = DB::table('users')
->whereNotBetween('votes', [1,
100])
->get();
$users = DB::table('users')
->whereIn('id', [1, 2, 3])
->get();
$users = DB::table('users')
->whereNotIn('id', [1, 2, 3])
->get();
$users = DB::table('users')
->whereExists(function($query) {
$query->select(DB::raw(1))
->from('orders')
->whereRaw('orders.user_id =
users.id');
})
->get();
select * from users
where exists (
select 1 from orders where orders.user_id =
users.id
)
3.1.2. Insertar Datos
• Insertar filas en una tabla
El constructor de consultas también proporciona un método insert para insertar
registros dentro de una tabla de la base de datos. El método insert acepta un
arreglo de nombres de columnas y valores:
• Insertar filas en una tabla con id auto incrementable
Si la tabla tiene un id de auto-incremento, usa el método insertGetId para insertar
un registro y recibir el ID:
• Insertar múltiples filas en una tabla
Puedes insertar varios registros dentro de la tabla con una sola llamada a insert
pasando un arreglo de arreglos. Cada arreglo representa una fila a ser insertada
dentro de la tabla:
DB::table('users')->insert(
['email' => 'john@example.com', 'votes' => 0]
);
)
DB::table('users')->insert([
['email' => 'taylor@example.com', 'votes' => 0],
['email' => 'dayle@example.com', 'votes' => 0]
]);
$id = DB::table('users')->insertGetId(
['email' => 'john@example.com', 'votes' => 0]
);
3.1.3. Actualizar datos
Además de insertar registros dentro de la base de datos, el constructor de
consultas también puede actualizar registros existentes usando el método
update. El método update, como el método insert, acepta un arreglo de pares de
columna y valor que contienen las columnas a ser actualizadas. Puedes restringir
la consulta update usando cláusulas where:
3.1.4. Eliminar datos
El constructor de consultas también puede ser usado para eliminar registros de la
tabla por medio del método delete. Puedes restringir instrucciones delete al
agregar cláusulas where antes de ejecutar el método delete:
Si deseas truncar la tabla completa, lo cual remueve todas las filas y reinicia el ID
de auto-incremento a cero, puedes usar el método truncate:
3.1.5. Transacciones
Una transacción es una propagación de uno o más cambios en la base de datos,
ya sea cuando se crea, se modifica o se elimina un registro. En la práctica suele
consistir en la agrupación de consultas SQL y su ejecución como parte de una
transacción.
La forma más sencilla de aplicar transacciones en nuestro código, es usando el
Facade DB::transaction() que agrega una transacción y hace el rollback por
nosotros. Pero al final envía una excepción que tenemos que manejar de alguna
forma. (Santos, 2021)
$affected = DB::table('users')
->where('id', 1)
->update(['votes' => 1]);
DB::table('users')->delete();
DB::table('users')->where('votes', '>', 100)-
>delete();
DB::table('users')->truncate();
4. Conclusiones.
De acuerdo a los procedimientos y ejemplos presentados se puede concluir que para
el correcto manejo de cada uno de estos parámetros de operaciones en base de datos
se necesita poner en practica cada uno de estas sentencias. Laravel facilita el uso de
procedimientos en SQL mediante su sin número de métodos de sentencias por lo cual
el uso de estas dependerá del desarrollador y los requerimientos del proyecto que
vaya a realizar. El soporte de base de datos de Query Builder es adaptativo y adecuado
para los diferentes gestores por lo cual se puede manejar de manera fluida su
conjunto de procedimientos.
class EmployeePositionController extends Controller
{
public function __invoke(Request $request)
{
try {
DB::transaction(function() use ($request) {
$employee = Employee::create([
'name' => $request->employee_name,
'email' => $request->employee_email
]);
$position = Position::create([
'name' => $request->position,
]);
$position->employees()->save($employee);
});
} catch (\Exception $e) {
return response()->json(['message' => 'Error']);
}
return response()->json(['message' => 'Success']);
}
}
5. Bibliografía.
Laravel. (s.f). Documentación de Laravel. Obtenido de
https://laravel.com/docs/9.x/queries#introduction
Palacios, D. (29 de Mayo de 2020). Styde. Obtenido de https://styde.net/laravel-6-doc-base-
de-datos-constructor-de-consultas-query-builder/#inserts
Santos, H. H. (21 de Febrero de 2021). DESARROLLO DE SOFTWARE EN LARAVEL. Obtenido
de https://herminioheredia.com.mx/2021/02/21/transacciones-en-laravel-
insertar-modelos-
relacionados/#:~:text=Las%20transacciones%20en%20Laravel%20son,evitar%20qu
e%20se%20pierdan%20datos.