Query Builder - Nixon Ortiz 5TO A TICS

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.