foxdb
1.0.0
El FoxDB Query Builder utiliza la unión de parámetros PDO para proteger su aplicación contra ataques de inyección SQL. No hay necesidad de limpiar o desinfectar cadenas pasadas al constructor de consultas como enlaces de consultas.
composer require webriumfoxdb
Configuración
Seleccionar
Insertar declaraciones
Actualizar declaraciones
Eliminar declaraciones
Características especiales
Esquema
Elocuente
use Foxdb DB ;
use Foxdb Config ;
DB :: addConnection ( ' main ' , [
' host ' => ' localhost ' ,
' port ' => ' 3306 ' ,
' database ' => ' test ' ,
' username ' => ' root ' ,
' password ' => ' 1234 ' ,
' charset ' =>Config:: UTF8 ,
' collation ' =>Config:: UTF8_GENERAL_CI ,
' fetch ' =>Config:: FETCH_CLASS
]);La instrucción
'main'es el nombre predeterminado de la configuración de conexión
Puede usar el método table proporcionado por la fachada DB para comenzar una consulta. El método table devuelve una instancia de constructor de consultas fluidas para la tabla dada, lo que le permite encadenar más restricciones en la consulta y luego finalmente recuperar los resultados de la consulta utilizando el método GET:
use Foxdb DB ;
$ users = DB :: table ( ' users ' )-> get ();
foreach ( $ users as $ user ) {
echo $ user -> name ;
} Si solo necesita recuperar una sola fila de una tabla de base de datos, puede usar el first método de la fachada de DB. Este método devolverá un solo objeto STDClass:
$ user = DB :: table ( ' users ' )-> where ( ' name ' , ' Jack ' )-> first ();
return $ user -> email ; Si no necesita una fila completa, puede extraer un solo valor de un registro utilizando el método value . Este método devolverá el valor de la columna directamente:
$ email = DB :: table ( ' users ' )-> where ( ' name ' , ' John ' )-> value ( ' email ' ); Para recuperar una sola fila por valor de su columna de id , use el método find :
$ user = DB :: table ( ' users ' )-> find ( 3 ); La diferencia entre el método find y first es que el first método devuelve el resultado en la forma de una Clase STD si existe, pero el método find devuelve el resultado en la forma de un Model , que nos proporciona más características. (Si el valor no existe, ambos métodos devuelven falsos).
? Desde la versión 3 y superior, las consultas se pueden usar para encontrar
$ user = User:: find ( 3 );
if ( $ user ){
$ user -> name = ' Tom ' ;
$ user -> save (); // update name
}
$ user = User:: where ( ' phone ' , ' 09999999999 ' )-> find ();
if ( $ user ){
$ user -> phone = ' 09999999998 ' ;
$ user -> save (); // update user phone number
} Puede usar el método pluck . En este ejemplo, recuperaremos una colección de títulos de usuario:
use Foxdb DB ;
$ titles = DB :: table ( ' users ' )-> pluck ( ' title ' );
foreach ( $ titles as $ title ) {
echo $ title ;
}Puede especificar la columna que la colección resultante debe usar como sus claves proporcionando un segundo argumento al método de despliegue:
$ titles = DB :: table ( ' users ' )-> pluck ( ' title ' , ' name ' );
foreach ( $ titles as $ name => $ title ) {
echo $ title ;
} Si necesita trabajar con miles de registros de bases de datos, considere usar el método chunk proporcionado por la fachada DB. Este método recupera una pequeña porción de resultados a la vez y alimenta cada fragmento en un cierre para su procesamiento. Por ejemplo, recuperemos toda la tabla de usuarios en trozos de 100 registros a la vez:
use Foxdb DB ;
DB :: table ( ' users ' )-> orderBy ( ' id ' )-> chunk ( 100 , function ( $ users ) {
foreach ( $ users as $ user ) {
//
}
});Puede evitar que más trozos se procesen devolviendo falsos del cierre:
DB :: table ( ' users ' )-> orderBy ( ' id ' )-> chunk ( 100 , function ( $ users ) {
// Process the records...
return false ;
}); puede usar each método.
use Foxdb DB ;
DB :: table ( ' users ' )-> orderBy ( ' id ' )-> each ( function ( $ user ) {
//
});FOXDB ha creado un método simple para la paginación. En el siguiente ejemplo, el número de resultados se limita a 10 registros, y puede obtener la información cambiando el número de página.
$ page = 1 ;
$ list = DB :: table ( ' posts ' )
-> is ( ' active ' )
-> paginate ( 10 , $ page );Su salida es una clase std que contiene las siguientes propiedades:
$ list -> total ; // The total number of rows
$ list -> count ; // The number of rows received on the current page
$ list -> per_page ; // The number of rows to display on each page
$ list -> prev_page ; // Previous page number. If not available, its value is false
$ list -> next_page ; // next page number. If not available, its value is false
$ list -> current_page ; // Current page number
$ list -> data ; // List of data rows El creador de consultas también proporciona una variedad de métodos para recuperar valores agregados como count , max , min , avg y sum . Puede llamar a cualquiera de estos métodos después de construir su consulta:
use Foxdb DB ;
$ users = DB :: table ( ' users ' )-> count ();
$ price = DB :: table ( ' orders ' )-> max ( ' price ' );Por supuesto, puede combinar estos métodos con otras cláusulas para ajustar cómo se calcula su valor agregado:
$ price = DB :: table ( ' orders ' )
-> where ( ' finalized ' , 1 )
-> avg ( ' price ' );En lugar de utilizar el método de recuento para determinar si existen registros que coincidan con las limitaciones de su consulta, puede usar los métodos exists y nocturnos:
if ( DB :: table ( ' orders ' )-> where ( ' finalized ' , 1 )-> exists ()) {
// ...
}
if ( DB :: table ( ' orders ' )-> where ( ' finalized ' , 1 )-> doesntExist ()) {
// ...
}Especificando una cláusula de selección
Es posible que no siempre desee seleccionar todas las columnas de una tabla de base de datos. Usando el método select , puede especificar una cláusula "Seleccionar" personalizada para la consulta:
use Foxdb DB ;
$ users = DB :: table ( ' users ' )
-> select ( ' name ' , ' email as user_email ' )
-> get ();
// Or you can send as an array
$ users = DB :: table ( ' users ' )
-> select ([ ' name ' , ' email as user_email ' ])
-> get ();Pero hay una forma más moderna de hacer esto. Puedes actuar como el ejemplo a continuación
$ users = DB :: table ( ' users ' )
-> select ( function ( $ query ){
$ query -> field ( ' name ' );
$ query -> field ( ' email ' )-> as ( ' user_email ' );
})
-> get (); A veces es posible que necesite insertar una cadena arbitraria en una consulta. Para crear una expresión de cadena sin procesar, puede usar el método raw proporcionado por la fachada DB :
$ users = DB :: table ( ' users ' )
-> select ( DB :: raw ( ' count(*) as user_count, status ' ))
-> where ( ' status ' , ' <> ' , 1 )
-> groupBy ( ' status ' )
-> get ();Para usar el parámetro en RAW como el ejemplo a continuación
DB::raw('count(?)',['id'])
️ Las declaraciones sin procesar se inyectarán en la consulta como cadenas, por lo que debe tener mucho cuidado para evitar crear vulnerabilidades de inyección SQL.
Pero para este propósito, es mejor usar el siguiente método para evitar el ataque SQL injection
$ users = DB :: table ( ' users ' )
-> select ( function ( $ query ){
$ query -> count ( ' * ' )-> as ( ' user_count ' )
$ query -> field ( ' status ' );
})
-> get (); En esta estructura, tiene acceso a field , count , sum , avg , min , max , all , as métodos.
En lugar de usar el método DB :: RAW, también puede usar los siguientes métodos para insertar una expresión sin procesar en varias partes de su consulta. Recuerde, FOXDB no puede garantizar que ninguna consulta que use expresiones crudas esté protegida contra las vulnerabilidades de inyección SQL.
Los métodos Whereraw y Oreweraw se pueden usar para inyectar una cláusula en bruto "donde" en su consulta. Estos métodos aceptan una matriz opcional de enlaces como segundo argumento:
$ orders = DB :: table ( ' orders ' )
-> whereRaw ( ' price > IF(state = "TX", ?, 100) ' , [ 200 ])
-> get ();Los métodos de tener Raw y OrhavingRaw pueden usarse para proporcionar una cadena sin procesar como el valor de la cláusula "tener". Estos métodos aceptan una matriz opcional de enlaces como segundo argumento:
$ orders = DB :: table ( ' orders ' )
-> select ( ' department ' , DB :: raw ( ' SUM(price) as total_sales ' ))
-> groupBy ( ' department ' )
-> havingRaw ( ' SUM(price) > ? ' , [ 2500 ])
-> get ();El creador de consultas también se puede usar para agregar cláusulas de unión a sus consultas. Para realizar una "unión interna" básica, puede usar el método de unión en una instancia de consulta. El primer argumento pasado al método de unión es el nombre de la tabla a la que debe unirse, mientras que los argumentos restantes especifican las restricciones de columna para la unión. Incluso puede unirse a varias tablas en una sola consulta:
use Foxdb DB ;
$ users = DB :: table ( ' users ' )
-> join ( ' contacts ' , ' users.id ' , ' = ' , ' contacts.user_id ' )
-> join ( ' orders ' , ' users.id ' , ' = ' , ' orders.user_id ' )
-> select ( ' users.* ' , ' contacts.phone ' , ' orders.price ' )
-> get ();En FoxDB, puedes hacerlo más fácilmente
$ users = DB :: table ( ' users ' )
-> select ( ' users.* ' , ' orders.price ' )
-> join ( ' orders.user_id ' , ' users.id ' )
-> get (); En esta estructura, ingresa el nombre de la tabla que desea unirse con su clave externa ( 'orders.user_id' ) y luego la clave principal ( 'user.id' ).
Si desea realizar una "Izquierda" o "Unión derecha" en lugar de una "unión interna", use los métodos de izquierda o derecho. Estos métodos tienen la misma firma que el método de unión:
$ users = DB :: table ( ' users ' )
-> leftJoin ( ' posts ' , ' users.id ' , ' = ' , ' posts.user_id ' )
-> get (); $ users = DB :: table ( ' users ' )
-> rightJoin ( ' posts ' , ' users.id ' , ' = ' , ' posts.user_id ' )
-> get ();Puede usar el método CrossJoin para realizar una "Cross Join". Cross Aips generan un producto cartesiano entre la primera tabla y la tabla unida:
$ sizes = DB :: table ( ' sizes ' )
-> crossJoin ( ' colors ' )
-> get ();Puede usar el método de la consulta donde el método donde agregará "donde" las cláusulas a la consulta. La llamada más básica al método Where requiere tres argumentos. El primer argumento es el nombre de la columna. El segundo argumento es un operador, que puede ser cualquiera de los operadores compatibles con la base de datos. El tercer argumento es el valor para compararse con el valor de la columna.
Por ejemplo, la siguiente consulta recupera a los usuarios donde el valor de la columna de votos es igual a 100 y el valor de la columna de edad es mayor que 35:
$ users = DB :: table ( ' users ' )
-> where ( ' votes ' , ' = ' , 100 )
-> where ( ' age ' , ' > ' , 35 )
-> get ();Por conveniencia, si desea verificar que una columna sea = a un valor dado, puede pasar el valor como el segundo argumento al método Where. FOXDB asumirá que le gustaría usar el operador =:
$ users = DB :: table ( ' users ' )-> where ( ' votes ' , 100 )-> get ();Como se mencionó anteriormente, puede usar cualquier operador que sea compatible con su sistema de base de datos:
$ 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 ();Al encadenar los llamados al método de la consulta Builder's Where, las cláusulas "donde" se unirán utilizando el operador y el operador. Sin embargo, puede usar el método ORWORY para unir una cláusula a la consulta utilizando el operador o. El método ORWORY acepta los mismos argumentos que el método Where:
$ users = DB :: table ( ' users ' )
-> where ( ' votes ' , ' > ' , 100 )
-> orWhere ( ' name ' , ' John ' )
-> get ();Si necesita agrupar una condición "o" dentro de los paréntesis, puede pasar un cierre como el primer argumento al método ORWORY:
$ users = DB :: table ( ' users ' )
-> where ( ' votes ' , ' > ' , 100 )
-> orWhere ( function ( $ query ) {
$ query -> where ( ' name ' , ' Abigail ' )
-> where ( ' votes ' , ' > ' , 50 );
})
-> get ();El ejemplo anterior producirá el siguiente SQL:
select * from users where votes > 100 or (name = 'Abigail' and votes > 50)
Los métodos de whereNot y orWhereNot pueden usarse para negar un grupo dado de restricciones de consulta. Por ejemplo, la siguiente consulta excluye productos que están en autorización o que tienen un precio que es inferior a diez:
$ products = DB :: table ( ' products ' )
-> whereNot ( function ( $ query ) {
$ query -> where ( ' clearance ' , true )
-> orWhere ( ' price ' , ' < ' , 10 );
})
-> get (); El método whereBetween verifica que el valor de una columna es entre dos valores:
$ users = DB :: table ( ' users ' )
-> whereBetween ( ' votes ' , [ 1 , 100 ])
-> get (); El método whereNotBetween verifica que el valor de una columna se encuentra fuera de dos valores:
$ users = DB :: table ( ' users ' )
-> whereNotBetween ( ' votes ' , [ 1 , 100 ])
-> get (); El método whereIn verifica que el valor de una columna dada está contenida dentro de la matriz dada:
$ users = DB :: table ( ' users ' )
-> whereIn ( ' id ' , [ 1 , 2 , 3 ])
-> get (); El método whereNotIn verifica que el valor de la columna dada no está contenido en la matriz dada:
$ users = DB :: table ( ' users ' )
-> whereNotIn ( ' id ' , [ 1 , 2 , 3 ])
-> get (); El método whereNull verifica que el valor de la columna dada es nulo:
$ users = DB :: table ( ' users ' )
-> whereNull ( ' updated_at ' )
-> get (); El método whereNotNull verifica que el valor de la columna no es nulo:
$ users = DB :: table ( ' users ' )
-> whereNotNull ( ' updated_at ' )
-> get (); El método whereDate se puede utilizar para comparar el valor de una columna con una fecha:
$ users = DB :: table ( ' users ' )
-> whereDate ( ' created_at ' , ' 2016-12-31 ' )
-> get (); El método whereMonth se puede utilizar para comparar el valor de una columna con un mes específico:
$ users = DB :: table ( ' users ' )
-> whereMonth ( ' created_at ' , ' 12 ' )
-> get (); El método whereDay se puede utilizar para comparar el valor de una columna con un día específico del mes:
$ users = DB :: table ( ' users ' )
-> whereDay ( ' created_at ' , ' 31 ' )
-> get (); El método whereYear se puede utilizar para comparar el valor de una columna con un año específico:
$ users = DB :: table ( ' users ' )
-> whereYear ( ' created_at ' , ' 2016 ' )
-> get (); El método whereTime se puede utilizar para comparar el valor de una columna con un tiempo específico:
$ users = DB :: table ( ' users ' )
-> whereTime ( ' created_at ' , ' = ' , ' 11:20:45 ' )
-> get (); El método whereColumn se puede usar para verificar que dos columnas son iguales:
$ users = DB :: table ( ' users ' )
-> whereColumn ( ' first_name ' , ' last_name ' )
-> get (); También puede pasar un operador de comparación al método whereColumn :
$ users = DB :: table ( ' users ' )
-> whereColumn ( ' updated_at ' , ' > ' , ' created_at ' )
-> get (); El método orderBy le permite ordenar los resultados de la consulta mediante una columna determinada. El primer argumento aceptado por el método orderBy debe ser la columna por la que desea ordenar, mientras que el segundo argumento determina la dirección del tipo y puede ser ASC o Desc:
$ users = DB :: table ( ' users ' )
-> orderBy ( ' name ' , ' desc ' )
-> get ();Para ordenar por varias columnas, simplemente puede invocar a Orderby tantas veces como sea necesario:
$ users = DB :: table ( ' users ' )
-> orderBy ( ' name ' , ' desc ' )
-> orderBy ( ' email ' , ' asc ' )
-> get (); Los métodos latest y oldest le permiten ordenar fácilmente los resultados por fecha. De manera predeterminada, el resultado será ordenado por la columna created_at de la tabla. O puede pasar el nombre de la columna que desea ordenar:
$ user = DB :: table ( ' users ' )
-> latest ()
-> first ();El método inrandomorder se puede usar para ordenar los resultados de la consulta al azar. Por ejemplo, puede usar este método para obtener un usuario aleatorio:
$ randomUser = DB :: table ( ' users ' )
-> inRandomOrder ()
-> first ();groupBy y having métodos Como es de esperar, el groupBy y having métodos pueden usarse para agrupar los resultados de la consulta. La firma del método having es similar a la del método Where:
$ users = DB :: table ( ' users ' )
-> groupBy ( ' account_id ' )
-> having ( ' account_id ' , ' > ' , 100 )
-> get ();Puede pasar múltiples argumentos al método Groupby para agrupar mediante múltiples columnas:
$ users = DB :: table ( ' users ' )
-> groupBy ( ' first_name ' , ' status ' )
-> having ( ' account_id ' , ' > ' , 100 )
-> get ();Para construir declaraciones más avanzadas, vea el método HavingRaw.
Puede usar los métodos skip y take para limitar el número de resultados devueltos de la consulta o para omitir un número dado de resultados en la consulta:
$ users = DB :: table ( ' users ' )-> skip ( 10 )-> take ( 5 )-> get (); Alternativamente, puede usar los métodos limit y offset . Estos métodos son funcionalmente equivalentes a los métodos de toma y omisión, respectivamente:
$ users = DB :: table ( ' users ' )
-> offset ( 10 )
-> limit ( 5 )
-> get (); El creador de consultas también proporciona un método insert que se puede usar para insertar registros en la tabla de la base de datos. El método de inserción acepta una matriz de nombres y valores de columna:
DB :: table ( ' users ' )-> insert ([
' email ' => ' [email protected] ' ,
' votes ' => 0
]); Si la tabla tiene una ID de incremento automático, use el método insertGetId para insertar un registro y luego recupere la ID:
$ id = DB :: table ( ' users ' )-> insertGetId (
[ ' email ' => ' [email protected] ' , ' votes ' => 0 ]
);Además de insertar registros en la base de datos, el constructor de consultas también puede actualizar los registros existentes utilizando el método de actualización. El método de actualización, como el método de inserción, acepta una matriz de pares de columna y valor que indica que las columnas se actualizarán. El método de actualización devuelve el número de filas afectadas. Puede restringir la consulta de actualización usando donde las cláusulas:
$ affected = DB :: table ( ' users ' )
-> where ( ' id ' , 1 )
-> update ([ ' votes ' => 1 ]);El constructor de consultas también proporciona métodos convenientes para incrementar o disminuir el valor de una columna determinada. Ambos métodos aceptan al menos un argumento: la columna para modificar. Se puede proporcionar un segundo argumento para especificar la cantidad por la cual la columna debe incrementarse o disminuir:
DB :: table ( ' users ' )-> increment ( ' votes ' );
DB :: table ( ' users ' )-> increment ( ' votes ' , 5 );
DB :: table ( ' users ' )-> decrement ( ' votes ' );
DB :: table ( ' users ' )-> decrement ( ' votes ' , 5 ); DB :: table ( ' users ' )-> where ( ' id ' , $ id )-> delete ();Puede usar la sintaxis más agradable, que además de acortar el código, también ayuda a hacer que el código sea más legible.
Para crear consultas basadas en boolean, puede usar is métodos true y false
$ active_list = DB :: table ( ' users ' )-> is ( ' active ' )-> get ();
// OR
$ active_list = DB :: table ( ' users ' )-> true ( ' active ' )-> get (); $ inactive_list = DB :: table ( ' users ' )-> is ( ' active ' , false )-> get ();
//OR
$ inactive_list = DB :: table ( ' users ' )-> false ( ' active ' )-> get ();No necesita usar el método Where para sus consultas consecutivamente. Puede usar el método y el uso o en lugar de o en el lugar.
Ejemplo:
DB :: table ( ' users ' )
-> is ( ' active ' )
-> and ( ' credit ' , ' > ' , 0 )
-> or ( ' vip ' , true )
-> get (); DB :: table ( ' users ' )
-> in ( ' id ' , [ 1 , 5 , 10 ])
-> get ();También hay otros métodos disponibles, como los siguientes métodos:
not(..) / orNot(..)
in(..) / notIn(..) / orIn(..) / orNotIn(..)
like(..) / orLike(..)
null(..) / orNull(..) / notNull(..) / orNotNull(..)
date(..) / orDate(..)
year(..) / orYear(..)
month(..) / orMonth(..)
day(..) / orDay(..)
time(..) / orTime(..)
