foxdb
1.0.0
O Builder de consulta FoxDB usa a ligação ao parâmetro PDO para proteger sua aplicação contra ataques de injeção de SQL. Não há necessidade de limpar ou higienizar as cordas passadas para o construtor de consultas como ligações de consulta.
composer require webriumfoxdb
Configuração
Selecione
Insira declarações
Atualizar declarações
Excluir declarações
Recursos especiais
Esquema
Eloquente
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
]);A declaração
'main'é o nome padrão da configuração da conexão
Você pode usar o método table fornecido pela fachada DB para iniciar uma consulta. O método table retorna uma instância fluente do construtor de consultas para a tabela fornecida, permitindo que você acorrente mais restrições na consulta e, finalmente, recupere os resultados da consulta usando o método GET:
use Foxdb DB ;
$ users = DB :: table ( ' users ' )-> get ();
foreach ( $ users as $ user ) {
echo $ user -> name ;
} Se você só precisar recuperar uma única linha de uma tabela de banco de dados, poderá usar o first método da fachada de banco de dados. Este método retornará um único objeto Stdclass:
$ user = DB :: table ( ' users ' )-> where ( ' name ' , ' Jack ' )-> first ();
return $ user -> email ; Se você não precisar de uma linha inteira, poderá extrair um único valor de um registro usando o método value . Este método retornará diretamente o valor da coluna:
$ email = DB :: table ( ' users ' )-> where ( ' name ' , ' John ' )-> value ( ' email ' ); Para recuperar uma única linha pelo seu valor de coluna de id , use o método find :
$ user = DB :: table ( ' users ' )-> find ( 3 ); A diferença entre o método find e first é que o first método retorna o resultado na forma de um stdclass, se existir, mas o método find retorna o resultado na forma de um Model , o que nos fornece mais recursos. (Se o valor não existir, ambos os métodos retornarem false.)
? Na versão 3 e acima, as consultas podem ser usadas 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
} Você pode usar o método pluck . Neste exemplo, recuperaremos uma coleção de títulos de usuários:
use Foxdb DB ;
$ titles = DB :: table ( ' users ' )-> pluck ( ' title ' );
foreach ( $ titles as $ title ) {
echo $ title ;
}Você pode especificar a coluna que a coleção resultante deve usar como chaves, fornecendo um segundo argumento ao método de arrancada:
$ titles = DB :: table ( ' users ' )-> pluck ( ' title ' , ' name ' );
foreach ( $ titles as $ name => $ title ) {
echo $ title ;
} Se você precisar trabalhar com milhares de registros de banco de dados, considere usar o método chunk fornecido pela fachada do banco de dados. Este método recupera um pequeno pedaço de resultados de cada vez e alimenta cada parte em um fechamento para o processamento. Por exemplo, vamos recuperar toda a tabela de usuários em pedaços de 100 registros por vez:
use Foxdb DB ;
DB :: table ( ' users ' )-> orderBy ( ' id ' )-> chunk ( 100 , function ( $ users ) {
foreach ( $ users as $ user ) {
//
}
});Você pode impedir que mais pedaços de serem processados retornando false do fechamento:
DB :: table ( ' users ' )-> orderBy ( ' id ' )-> chunk ( 100 , function ( $ users ) {
// Process the records...
return false ;
}); você pode usar o each .
use Foxdb DB ;
DB :: table ( ' users ' )-> orderBy ( ' id ' )-> each ( function ( $ user ) {
//
});A FoxDB criou um método simples para a paginação. No exemplo abaixo, o número de resultados é limitado a 10 registros e você pode obter as informações alterando o número da página.
$ page = 1 ;
$ list = DB :: table ( ' posts ' )
-> is ( ' active ' )
-> paginate ( 10 , $ page );Sua saída é um stdclass contendo as seguintes propriedades:
$ 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 O Consultor Construtora também fornece uma variedade de métodos para recuperar valores agregados como count , max , min , avg e sum . Você pode chamar qualquer um desses métodos após a construção de sua consulta:
use Foxdb DB ;
$ users = DB :: table ( ' users ' )-> count ();
$ price = DB :: table ( ' orders ' )-> max ( ' price ' );Obviamente, você pode combinar esses métodos com outras cláusulas para ajustar como o valor agregado é calculado:
$ price = DB :: table ( ' orders ' )
-> where ( ' finalized ' , 1 )
-> avg ( ' price ' );Em vez de usar o método de contagem para determinar se existem registros que correspondam às restrições da sua consulta, você pode usar os métodos existentes e nãoxistas:
if ( DB :: table ( ' orders ' )-> where ( ' finalized ' , 1 )-> exists ()) {
// ...
}
if ( DB :: table ( ' orders ' )-> where ( ' finalized ' , 1 )-> doesntExist ()) {
// ...
}Especificando uma cláusula selecionada
Você nem sempre deseja selecionar todas as colunas de uma tabela de banco de dados. Usando o método select , você pode especificar uma cláusula "Selecionar" personalizada para a 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 ();Mas há uma maneira mais moderna de fazer isso. Você pode agir como o exemplo abaixo
$ users = DB :: table ( ' users ' )
-> select ( function ( $ query ){
$ query -> field ( ' name ' );
$ query -> field ( ' email ' )-> as ( ' user_email ' );
})
-> get (); Às vezes, pode ser necessário inserir uma string arbitrária em uma consulta. Para criar uma expressão de string crua, você pode usar o método raw fornecido pela fachada DB :
$ users = DB :: table ( ' users ' )
-> select ( DB :: raw ( ' count(*) as user_count, status ' ))
-> where ( ' status ' , ' <> ' , 1 )
-> groupBy ( ' status ' )
-> get ();Para usar o parâmetro em Raw, como o exemplo abaixo
DB::raw('count(?)',['id'])
️ As declarações brutas serão injetadas na consulta como cordas, portanto, você deve ter muito cuidado para evitar a criação de vulnerabilidades de injeção de SQL.
Mas, para esse fim, é melhor usar o seguinte método para evitar o ataque SQL injection
$ users = DB :: table ( ' users ' )
-> select ( function ( $ query ){
$ query -> count ( ' * ' )-> as ( ' user_count ' )
$ query -> field ( ' status ' );
})
-> get (); Nesta estrutura, você tem acesso ao field , count , sum , avg , min , max , all , as métodos.
Em vez de usar o método DB :: RAW, você também pode usar os seguintes métodos para inserir uma expressão bruta em várias partes da sua consulta. Lembre -se de que a FoxDB não pode garantir que qualquer consulta usando expressões brutas seja protegida contra vulnerabilidades de injeção de SQL.
Os métodos WhheReRaw e OrwheReraw podem ser usados para injetar uma cláusula "WHERE" RAW em sua consulta. Esses métodos aceitam uma variedade opcional de ligações como seu segundo argumento:
$ orders = DB :: table ( ' orders ' )
-> whereRaw ( ' price > IF(state = "TX", ?, 100) ' , [ 200 ])
-> get ();Os métodos RAWRAW e ORHAVERRAW podem ser usados para fornecer uma sequência bruta como o valor da cláusula "tendo". Esses métodos aceitam uma variedade opcional de ligações como seu segundo argumento:
$ orders = DB :: table ( ' orders ' )
-> select ( ' department ' , DB :: raw ( ' SUM(price) as total_sales ' ))
-> groupBy ( ' department ' )
-> havingRaw ( ' SUM(price) > ? ' , [ 2500 ])
-> get ();O Construtor do Consulta também pode ser usado para adicionar cláusulas de junção às suas consultas. Para executar uma "junção interna" básica, você pode usar o método de junção em uma instância de consultor de consultas. O primeiro argumento passado para o método de junção é o nome da tabela para a qual você precisa participar, enquanto os argumentos restantes especificam as restrições da coluna para a junção. Você pode até se juntar a várias tabelas em uma única 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 ();No FoxDB, você pode fazer isso mais facilmente
$ users = DB :: table ( ' users ' )
-> select ( ' users.* ' , ' orders.price ' )
-> join ( ' orders.user_id ' , ' users.id ' )
-> get (); Nesta estrutura, você insere o nome da tabela que deseja participar de sua chave estrangeira ( 'orders.user_id' ) e depois a chave primária ( 'user.id' ).
Se você deseja executar uma "junção esquerda" ou "junção direita" em vez de uma "junção interna", use os métodos de jofra ou direita. Esses métodos têm a mesma assinatura que o método de junção:
$ users = DB :: table ( ' users ' )
-> leftJoin ( ' posts ' , ' users.id ' , ' = ' , ' posts.user_id ' )
-> get (); $ users = DB :: table ( ' users ' )
-> rightJoin ( ' posts ' , ' users.id ' , ' = ' , ' posts.user_id ' )
-> get ();Você pode usar o método Crossjoin para executar uma "junção cruzada". As junções cruzadas geram um produto cartesiano entre a primeira tabela e a mesa unida:
$ sizes = DB :: table ( ' sizes ' )
-> crossJoin ( ' colors ' )
-> get ();Você pode usar o método WHERE WHERE para adicionar "onde" as cláusulas da consulta à consulta. A chamada mais básica para o método WHERE requer três argumentos. O primeiro argumento é o nome da coluna. O segundo argumento é um operador, que pode ser qualquer um dos operadores suportados do banco de dados. O terceiro argumento é o valor a ser comparado com o valor da coluna.
Por exemplo, a consulta a seguir recupera os usuários onde o valor da coluna de votos é igual a 100 e o valor da coluna de idade é maior que 35:
$ users = DB :: table ( ' users ' )
-> where ( ' votes ' , ' = ' , 100 )
-> where ( ' age ' , ' > ' , 35 )
-> get ();Por conveniência, se você deseja verificar se uma coluna é = para um determinado valor, poderá passar o valor como o segundo argumento para o método where. FoxDB assumirá que você gostaria de usar o = operador:
$ users = DB :: table ( ' users ' )-> where ( ' votes ' , 100 )-> get ();Como mencionado anteriormente, você pode usar qualquer operador suportado pelo seu sistema de banco de dados:
$ 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 ();Ao encadear chamadas para o método do Wherey Builder, o método, as cláusulas "onde" serão unidas usando o operador e o operador. No entanto, você pode usar o método ou lugar para ingressar em uma cláusula na consulta usando o operador ou. O método ou onde aceita os mesmos argumentos que o método WHERE:
$ users = DB :: table ( ' users ' )
-> where ( ' votes ' , ' > ' , 100 )
-> orWhere ( ' name ' , ' John ' )
-> get ();Se você precisar agrupar uma condição "ou" entre parênteses, poderá passar um fechamento como o primeiro argumento para o método ou lugar:
$ users = DB :: table ( ' users ' )
-> where ( ' votes ' , ' > ' , 100 )
-> orWhere ( function ( $ query ) {
$ query -> where ( ' name ' , ' Abigail ' )
-> where ( ' votes ' , ' > ' , 50 );
})
-> get ();O exemplo acima produzirá o seguinte SQL:
select * from users where votes > 100 or (name = 'Abigail' and votes > 50)
Os métodos whereNot os métodos de orWhereNot podem ser usados para negar um determinado grupo de restrições de consulta. Por exemplo, a consulta a seguir exclui produtos que estão em autorização ou que têm um preço inferior a dez:
$ products = DB :: table ( ' products ' )
-> whereNot ( function ( $ query ) {
$ query -> where ( ' clearance ' , true )
-> orWhere ( ' price ' , ' < ' , 10 );
})
-> get (); O método whereBetween o método verifica se o valor de uma coluna está entre dois valores:
$ users = DB :: table ( ' users ' )
-> whereBetween ( ' votes ' , [ 1 , 100 ])
-> get (); O método whereNotBetween verifica que o valor de uma coluna está fora de dois valores:
$ users = DB :: table ( ' users ' )
-> whereNotBetween ( ' votes ' , [ 1 , 100 ])
-> get (); O método whereIn verifica que o valor de uma determinada coluna está contido dentro da matriz dada:
$ users = DB :: table ( ' users ' )
-> whereIn ( ' id ' , [ 1 , 2 , 3 ])
-> get (); O método whereNotIn verifica que o valor da coluna fornecido não está contido na matriz dada:
$ users = DB :: table ( ' users ' )
-> whereNotIn ( ' id ' , [ 1 , 2 , 3 ])
-> get (); O método whereNull o método verifica se o valor da coluna especificada é nulo:
$ users = DB :: table ( ' users ' )
-> whereNull ( ' updated_at ' )
-> get (); O método whereNotNull verifica se o valor da coluna não é nulo:
$ users = DB :: table ( ' users ' )
-> whereNotNull ( ' updated_at ' )
-> get (); O método whereDate pode ser usado para comparar o valor de uma coluna com uma data:
$ users = DB :: table ( ' users ' )
-> whereDate ( ' created_at ' , ' 2016-12-31 ' )
-> get (); O método whereMonth pode ser usado para comparar o valor de uma coluna com um mês específico:
$ users = DB :: table ( ' users ' )
-> whereMonth ( ' created_at ' , ' 12 ' )
-> get (); O método whereDay pode ser usado para comparar o valor de uma coluna com um dia específico do mês:
$ users = DB :: table ( ' users ' )
-> whereDay ( ' created_at ' , ' 31 ' )
-> get (); O método whereYear pode ser usado para comparar o valor de uma coluna com um ano específico:
$ users = DB :: table ( ' users ' )
-> whereYear ( ' created_at ' , ' 2016 ' )
-> get (); O método whereTime pode ser usado para comparar o valor de uma coluna com um horário específico:
$ users = DB :: table ( ' users ' )
-> whereTime ( ' created_at ' , ' = ' , ' 11:20:45 ' )
-> get (); O método whereColumn pode ser usado para verificar se duas colunas são iguais:
$ users = DB :: table ( ' users ' )
-> whereColumn ( ' first_name ' , ' last_name ' )
-> get (); Você também pode passar por um operador de comparação para o método whereColumn :
$ users = DB :: table ( ' users ' )
-> whereColumn ( ' updated_at ' , ' > ' , ' created_at ' )
-> get (); O método orderBy permite classificar os resultados da consulta por uma determinada coluna. O primeiro argumento aceito pelo método orderBy deve ser a coluna que você deseja classificar, enquanto o segundo argumento determina a direção do tipo e pode ser ASC ou DESC:
$ users = DB :: table ( ' users ' )
-> orderBy ( ' name ' , ' desc ' )
-> get ();Para classificar por várias colunas, você pode simplesmente invocar o pedido muitas vezes for necessário:
$ users = DB :: table ( ' users ' )
-> orderBy ( ' name ' , ' desc ' )
-> orderBy ( ' email ' , ' asc ' )
-> get (); Os métodos latest e oldest permitem solicitar facilmente os resultados por data. Por padrão, o resultado será encomendado pela coluna created_at da tabela. Ou você pode passar no nome da coluna que deseja classificar:
$ user = DB :: table ( ' users ' )
-> latest ()
-> first ();O método de inagurdomomer pode ser usado para classificar os resultados da consulta aleatoriamente. Por exemplo, você pode usar este método para buscar um usuário aleatório:
$ randomUser = DB :: table ( ' users ' )
-> inRandomOrder ()
-> first ();groupBy e having métodos Como você pode esperar, o groupBy e having métodos podem ser usados para agrupar os resultados da consulta. A having do Method é semelhante à do método WHERE:
$ users = DB :: table ( ' users ' )
-> groupBy ( ' account_id ' )
-> having ( ' account_id ' , ' > ' , 100 )
-> get ();Você pode passar vários argumentos para o método do grupo para agrupar por várias colunas:
$ users = DB :: table ( ' users ' )
-> groupBy ( ' first_name ' , ' status ' )
-> having ( ' account_id ' , ' > ' , 100 )
-> get ();Para construir mais avançados com declarações, consulte o método de teria.
Você pode usar os métodos skip and take para limitar o número de resultados retornados da consulta ou para pular um determinado número de resultados na consulta:
$ users = DB :: table ( ' users ' )-> skip ( 10 )-> take ( 5 )-> get (); Como alternativa, você pode usar os métodos de limit e offset . Esses métodos são funcionalmente equivalentes aos métodos de tomada e pula, respectivamente:
$ users = DB :: table ( ' users ' )
-> offset ( 10 )
-> limit ( 5 )
-> get (); O Consultor Construtor também fornece um método insert que pode ser usado para inserir registros na tabela de banco de dados. O método Insert aceita uma matriz de nomes e valores de colunas:
DB :: table ( ' users ' )-> insert ([
' email ' => ' [email protected] ' ,
' votes ' => 0
]); Se a tabela tiver um ID de incrementação automática, use o método insertGetId para inserir um registro e depois recuperar o ID:
$ id = DB :: table ( ' users ' )-> insertGetId (
[ ' email ' => ' [email protected] ' , ' votes ' => 0 ]
);Além de inserir registros no banco de dados, o Consulta Builder também pode atualizar os registros existentes usando o método de atualização. O método de atualização, como o método Insert, aceita uma matriz de pares de coluna e valor indicando as colunas a serem atualizadas. O método de atualização retorna o número de linhas afetadas. Você pode restringir a consulta de atualização usando onde as cláusulas:
$ affected = DB :: table ( ' users ' )
-> where ( ' id ' , 1 )
-> update ([ ' votes ' => 1 ]);O Construtor do Consulta também fornece métodos convenientes para incrementar ou diminuir o valor de uma determinada coluna. Ambos os métodos aceitam pelo menos um argumento: a coluna para modificar. Um segundo argumento pode ser fornecido para especificar a quantidade pela qual a coluna deve ser incrementada ou decrescente:
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 ();Você pode usar a sintaxe mais agradável, que além de encurtar o código, também ajuda a tornar o código mais legível
Para criar consultas baseadas em booleanos, você pode usar is métodos true e 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 ();Você não precisa usar o método WHERE para suas consultas consecutivamente. Você pode usar o e método ou uso ou em vez de ou onde.
Exemplo:
DB :: table ( ' users ' )
-> is ( ' active ' )
-> and ( ' credit ' , ' > ' , 0 )
-> or ( ' vip ' , true )
-> get (); DB :: table ( ' users ' )
-> in ( ' id ' , [ 1 , 5 , 10 ])
-> get ();Outros métodos também estão disponíveis, como os seguintes métodos:
not(..) / orNot(..)
in(..) / notIn(..) / orIn(..) / orNotIn(..)
like(..) / OR orLike(..)
null(..) / orNull(..) / notNull(..) / orNotNull(..)
date(..) / orDate(..)
year(..) / orYear(..)
month(..) / orMonth(..)
day(..) / orDay(..)
time(..) / orTime(..)
