php dbhandler
1.0.0
PHP-DbHandler é uma biblioteca PHP projetada para simplificar as interações com bancos de dados MySQL. Ele oferece um conjunto abrangente de ferramentas para construir e executar consultas, gerenciar transações e manipular esquemas de banco de dados por meio de conexões PDO.
Where e Havingor e and operadoresInstale o pacote via Composer:
composer require tribal2/db-handler Comece criando uma instância Db :
use Tribal2 DbHandler Core PDOWrapper ;
use Tribal2 DbHandler Db ;
use Tribal2 DbHandler DbConfig ;
$ config = DbConfig:: create ( ' my_database ' )
-> withUser ( ' username ' )
-> withPassword ( ' password ' )
-> withHost ( ' localhost ' ) // Optional. Default: 'localhost'
-> withPort ( 3306 ) // Optional. Default: 3306
-> withCharset ( ' utf8mb4 ' ); // Optional. Default: 'utf8mb4'
$ pdoWrapper = new PDOWrapper (
$ config ,
// Optional PsrLogLoggerInterface instance.
// $logger, // Default: PsrLogNullLogger
);
$ db = new Db (
$ pdoWrapper ,
// Optional PsrSimpleCacheCacheInterface instance.
// $cache, // Default: NULL
);Where e HavingA classe Where fornece uma maneira flexível e intuitiva de construir condições de consulta. Ele oferece suporte a uma variedade de operadores lógicos e de comparação, permitindo definir com precisão os critérios para selecionar ou filtrar dados de seu banco de dados.
Os métodos retornam um objeto Where encapsulando a condição, juntamente com um valor parametrizado para consultas seguras e eficientes.
As cláusulas Where não apenas simplificam a construção da sintaxe da consulta, mas também aumentam a segurança ao gerenciar internamente os riscos associados à injeção de SQL. Esta biblioteca substitui automaticamente valores por parâmetros nomeados PDO e executa a ligação usando os tipos de dados PDO apropriados. Ao lidar com esses aspectos cruciais, você garante que suas consultas não sejam apenas limpas e fáceis de manter, mas também seguras.
Você não precisa mais se preocupar em higienizar manualmente suas entradas para consultas ao banco de dados. A biblioteca se encarrega de preparar as instruções de forma a proteger contra a injeção de SQL, uma das vulnerabilidades de segurança mais comuns em aplicativos orientados a banco de dados. Essa abordagem permite que você se concentre na lógica de negócios do seu aplicativo, confiando que as interações com o banco de dados serão tratadas de forma segura e eficiente.
$ where = Where:: equals ( ' status ' , ' active ' );
// Output: `status` = :status___1
$ where = Where:: notEquals ( ' category ' , ' archived ' );
// Output: `category` <> :category___1
$ where = Where:: greaterThan ( ' price ' , 100 );
// Output: `price` > :price___1
$ where = Where:: greaterThanOrEquals ( ' price ' , 100 );
// Output: `price` >= :price___1
$ where = Where:: lessThan ( ' price ' , 50 );
// Output: `price` < :price___1
$ where = Where:: lessThanOrEquals ( ' price ' , 50 );
// Output: `price` <= :price___1
$ where = Where:: isNull ( ' description ' );
// Output: `description` IS NULL
$ whereNotNull = Where:: isNotNull ( ' description ' );
// Output: Output: `description` IS NOT NULL $ where = Where:: like ( ' name ' , ' %Apple% ' );
// Output: `name` LIKE :name___1
$ where = Where:: notLike ( ' name ' , ' %Apple% ' );
// Output: `name` NOT LIKE :name___1
$ where = Where:: between ( ' date ' , ' 2021-01-01 ' , ' 2021-12-31 ' );
// Output: `date` BETWEEN :date___1 AND :date___2
$ where = Where:: notBetween ( ' date ' , ' 2021-01-01 ' , ' 2021-12-31 ' );
// Output: `date` NOT BETWEEN :date___1 AND :date___2
$ where = Where:: in ( ' status ' , [ ' active ' , ' pending ' , ' on-hold ' ]);
// Output: `status` IN (:status___1, :status___2, :status___3)
$ where = Where:: notIn ( ' status ' , [ ' active ' , ' pending ' , ' on-hold ' ]);
// Output: `status` NOT IN (:status___1, :status___2, :status___3)or e and operadores $ where1 = Where:: equals ( ' status ' , ' active ' );
$ where2 = Where:: greaterThan ( ' price ' , 100 );
$ orWhere = Where:: or ( $ where1 , $ where2 );
// Output: (`status` = :status___1 OR `price` > :price___1)
$ andWhere = Where:: and ( $ where1 , $ where2 );
// Output: (`status` = :status___1 AND `price` > :price___1)Você também pode aninhar operadores
oreand:
$ where3 = Where:: equals ( ' category ' , ' archived ' );
$ combinedWhere = Where:: and ( $ where3 , $ orWhere );
// Output: (`category` = :category___1 AND (`status` = :status___1 OR `price` > :price___1)) Nas subseções a seguir, exploraremos como criar e executar consultas usando esta biblioteca. Para simplificar, assumiremos que a variável $db é uma instância da classe Db .
Em todos os exemplos abaixo, separamos a construção da consulta da execução. Essa abordagem permite reutilizar o objeto de consulta e executá-lo várias vezes com parâmetros diferentes, mas você também pode encadear os métodos para criar e executar a consulta em uma única instrução como esta:
$ results = $ db
-> select ()
-> columns ([ ' column1 ' , ' column2 ' ])
-> from ( ' table_name ' )
-> where (Where:: equals ( ' column2 ' , 1 ))
-> fethAll (); $ select = $ db -> select ()
-> columns ([ ' column1 ' , ' column2 ' ])
-> column ( ' column3 ' )
-> from ( ' table_name ' )
-> where (Where:: equals ( ' column2 ' , 1 )) // See "Where Clauses" section above
-> groupBy ( ' column1 ' )
-> having (Where:: equals ( ' sum(column2) ' , 5 ))
-> orderBy ( ' column3 ' , ' ASC ' )
-> limit ( 10 )
-> offset ( 5 );
$ sql = $ select -> getSql ();
// $sql:
// SELECT
// `column1`,
// `column2`,
// `column3`
// FROM
// `table_name`
// WHERE
// `column2` = :column2___1
// GROUP BY
// `column1`
// HAVING
// `sum(column2)` = :sum_column2____1
// ORDER BY
// `column3` ASC
// LIMIT
// 10
// OFFSET
// 5;Buscando resultados:
Por padrão, o método fetchAll() retorna um array de objetos (usando PDO::FETCH_OBJ por padrão), onde cada objeto representa uma linha de dados. Você também pode buscar os resultados como uma matriz de matrizes associativas, passando a constante PDO::FETCH_ASSOC como um argumento para o método construtor fetchMethod() antes de executar a consulta.
$ allResults = $ select -> fetchAll ();
$ firstResult = $ select -> fetchFirst ();
$ column1Values = $ select -> fetchColumn ( ' column1 ' );
$ column3DistinctValues = $ select -> fetchDistincts ( ' column3 ' );
// Output: object(FetchResult) {
// data => array(n) {
// [0]...
// [1]...
// [n-1]...
// },
// count => int(n)
// }Você também pode buscar a contagem de resultados com:
$ countResults = $ select -> fetchCount ();
// Output: 5Paginação:
O manuseio eficiente de grandes conjuntos de dados e o fornecimento de uma interface amigável para navegação de dados são essenciais para qualquer aplicação robusta. O recurso de paginação no PHP-DbHandler atende a essas necessidades com elegância. Ele simplifica o processo de divisão de seus dados em partes gerenciáveis, ou “páginas”, facilitando o trabalho com grandes conjuntos de dados sem sobrecarregar o sistema ou o usuário.
Configurando paginação
Existem duas maneiras de configurar a paginação para suas consultas:
Usando o método paginate: Este método permite definir o número de itens por página de forma concisa. É uma forma eficiente de preparar sua consulta para paginação.
$ select = $ db -> select ()
-> from ( ' table_name ' )
// ...
-> paginate (itemsPerPage: 10 );Definir limite e deslocamento manualmente: para obter mais controle, você pode especificar manualmente o limite (número de itens por página) e o deslocamento (ponto inicial no conjunto de dados) para sua consulta.
$ select = $ db -> select ()
-> from ( ' table_name ' )
// ...
-> limit ( 10 )
-> offset ( 0 );Buscando resultados com paginação
Depois que a paginação estiver configurada, você poderá buscar resultados de várias maneiras, navegando pelo seu conjunto de dados com facilidade:
fetchPage(?int $page) : busca uma página atual ou específica.fetchNextPage() : busca resultados para a próxima página.fetchPreviousPage() : busca resultados da página anterior.fetchFirstPage() : busca resultados para a primeira página.fetchLastPage() : busca os resultados da última página. Cada um desses métodos retorna um objeto FetchPaginatedResult , que contém as seguintes propriedades:
data : uma matriz dos registros na página atual.count : o número total de registros no conjunto de dados.page : O número da página atual.perPage : o número de registros por página.totalPages : o número total de páginas. // Example output structure of FetchPaginatedResult
object (FetchPaginatedResult) {
data => array (n) {
[ 0 ]. . .
[ 1 ]. . .
[n- 1 ]. . .
},
count => int(n),
page => int( 10 ),
perPage => int( 10 ),
totalPages => int( 23 )
}Este sistema de paginação em PHP-DbHandler garante que você possa gerenciar e navegar com eficácia por grandes conjuntos de dados, melhorando o desempenho geral e a experiência do usuário de seu aplicativo.
Cache:
Nas aplicações atuais baseadas em dados, a eficiência e o desempenho são fundamentais. Para aprimorar esses aspectos nas interações com o banco de dados, a biblioteca inclui um recurso de cache em suas consultas Select . Esse recurso aumenta o desempenho armazenando em cache os resultados da consulta, reduzindo assim a carga do banco de dados e melhorando os tempos de resposta para consultas executadas com frequência. É importante ressaltar que ele foi projetado para ser totalmente compatível com o padrão PSR-16 (Simple Cache), garantindo ampla compatibilidade e flexibilidade.
Cache compatível com PSR-16
A funcionalidade de cache nas consultas Select aceita qualquer instância de cache que implemente PsrSimpleCacheCacheInterface. Essa conformidade com os padrões PSR-16 significa que você pode integrar perfeitamente uma ampla variedade de bibliotecas de cache que aderem a essa interface, oferecendo flexibilidade para escolher a solução de cache que melhor atende às necessidades da sua aplicação.
PsrSimpleCacheCacheInterface ao inicializar a classe Db , você pode pular esta etapa. Se não, você pode usar o método setCache : $ select = $ db -> select ()-> setCache ( $ simpleCacheInstance );Notas:
- Se você não forneceu uma instância de cache ao inicializar a classe
Db, deverá defini-la para cada consultaSelectque deseja armazenar em cache.- Você também pode usar esse método se quiser definir uma instância de cache específica para uma consulta
Select. Isso permite que você use diferentes soluções de cache para diferentes consultas, dependendo das necessidades do seu aplicativo.
withCache . Você pode especificar um valor de retorno padrão para entradas de cache ausentes e um TTL (Time To Live) para os dados armazenados em cache. $ select -> withCache (defaultValue, ttl);Notas:
- O argumento
defaultValueé opcional. Se não for fornecido, a biblioteca retornaráNULLpara entradas de cache ausentes.- O argumento
ttlé opcional. Se não for fornecido, a biblioteca usará o valor TTL definido pela instância PsrSimpleCache.
$ allResults = $ select -> fetchAll ();
$ firstResult = $ select -> fetchFirst ();
$ column1Values = $ select -> fetchColumn ( ' column1 ' );
$ column3DistinctValues = $ select -> fetchDistincts ( ' column3 ' );Principais benefícios
A classe Insert na biblioteca PHP-DbHandler agiliza o processo de criação e execução de consultas de inserção em um banco de dados. Esta classe, equipada com múltiplas características e interfaces, oferece uma abordagem sofisticada para lidar com operações de inserção com vários recursos avançados.
Geração de consulta
Insert permite atribuir valores dinamicamente às colunas para inserção. Você pode adicionar um único valor ou vários valores de uma só vez: $ insert = $ db -> insert ()
-> into ( ' table_name ' )
-> value ( ' column1 ' , ' value1 ' )
-> values ([ ' column2 ' => ' value2 ' , ' column3 ' => ' value3 ' ]);A classe verificará se a coluna existe na tabela antes de adicionar o valor, e também cuidará da ligação necessária do PDO.
$ rows = [
[ ' column1 ' => ' value1 ' , ' column2 ' => ' value2 ' ],
[ ' column1 ' => ' value3 ' , ' column2 ' => ' value4 ' ],
// ...
];
$ insert -> rows ( $ rows );Execução
$ success = $ insert -> execute ();Cheques
Antes de executar uma operação de inserção, a classe verificará automaticamente:
- Se o banco de dados estiver em modo somente leitura , evitando operações de gravação não intencionais.
- Se houver colisões em chaves primárias sem incremento automático , garantindo a integridade dos dados.
A classe Insert é uma solução abrangente para lidar com operações de inserção em um banco de dados, oferecendo facilidade de uso e recursos avançados para gerenciar tarefas complexas de inserção com eficiência.
A classe Update na biblioteca PHP-DbHandler fornece uma maneira sofisticada e flexível de construir e executar consultas de atualização em um banco de dados. Ele foi projetado para se integrar perfeitamente à estrutura de banco de dados existente, ao mesmo tempo que oferece recursos robustos para gerenciar as operações de atualização de maneira eficaz.
Geração de consulta
$ update = $ db -> update ()
-> table ( ' table_name ' )
-> set ( ' column1 ' , ' newValue1 ' )
-> set ( ' column2 ' , ' newValue2 ' );
```
2. **Conditional Updates**: Incorporate conditions into your update queries using the `where` method. This allows for precise targeting of records to be updated.
``` php
$ update -> where (Where:: equals ( ' column3 ' , ' conditionValue ' ));Execução
$ success = $ update -> execute ();Verificação do modo somente leitura : antes da execução, a classe verifica se o banco de dados está no modo somente leitura, evitando assim operações de gravação não intencionais.
A classe Update representa uma solução abrangente para construir e executar operações de atualização em um banco de dados. Sua combinação de flexibilidade, robustez e facilidade de uso o torna a escolha ideal para gerenciar atualizações de banco de dados em aplicações PHP.
A classe Delete na biblioteca PHP-DbHandler oferece uma abordagem sofisticada para construir e executar consultas de exclusão em bancos de dados. Esta classe garante que as operações de exclusão sejam conduzidas com precisão e segurança, integrando verificações e recursos essenciais para um tratamento ideal de consultas.
Geração de consulta
A classe permite o direcionamento preciso de registros a serem excluídos usando expressões condicionais. Isto é conseguido através do método where , permitindo que linhas específicas sejam selecionadas para exclusão com base nos critérios fornecidos.
$ delete = $ db -> delete ()
-> from ( ' table_name ' )
-> where (Where:: equals ( ' column ' , ' value ' ));Cláusula Where obrigatória : para evitar a exclusão acidental de todos os registros em uma tabela, a classe exige que uma cláusula
WHEREseja especificada. Isso serve como uma proteção contra exclusões em massa não intencionais.
Execução
$ success = $ delete -> execute ();A classe realiza verificações essenciais antes de executar a operação de exclusão, incluindo a verificação da existência da tabela e a garantia de que o banco de dados não esteja no modo somente leitura.
A classe Delete foi projetada para lidar com operações de exclusão com alto grau de controle e segurança. Garante que as exclusões sejam realizadas com precisão, respeitando a estrutura e as restrições do banco de dados. Esteja você executando tarefas de exclusão simples ou complexas, esta classe fornece as ferramentas necessárias para executá-las de maneira confiável e segura.
A classe StoredProcedure na biblioteca PHP-DbHandler oferece uma abordagem simplificada e eficiente para executar procedimentos armazenados em bancos de dados. Esta classe fornece uma maneira robusta de interagir com procedimentos armazenados, lidando com gerenciamento de parâmetros, execução e busca de resultados com facilidade.
Geração de consulta
Configurando chamadas de procedimento armazenado : configure facilmente chamadas para procedimentos armazenados com gerenciamento dinâmico de parâmetros. Especifique o nome do procedimento e os parâmetros necessários.
$ procedure = $ db -> storedProcedure ()
-> call ( ' procedure_name ' )
-> with ( ' paramName ' , $ value )
// ...
-> with ( ' paramName2 ' , $ value );Execução
$ results = $ procedure -> execute ();Verificações no modo somente leitura : Antes da execução, a classe verifica se o banco de dados está no modo somente leitura, garantindo que as operações de gravação não sejam executadas involuntariamente.
A classe StoredProcedure é uma ferramenta indispensável para lidar com chamadas de procedimentos armazenados em aplicativos PHP. Simplifica a interação com procedimentos armazenados, tornando o processo mais intuitivo e menos sujeito a erros, especialmente em aplicações que dependem fortemente de operações complexas de banco de dados.
O gerenciamento de transações de banco de dados é um aspecto crucial para garantir a integridade dos dados, especialmente em aplicações que lidam com manipulação complexa de dados. PHP-DbHandler simplifica esse processo, oferecendo uma maneira intuitiva e direta de lidar com transações.
Com os recursos de gerenciamento de transações fornecidos, você pode facilmente iniciar, confirmar ou reverter transações, proporcionando controle total sobre as operações do seu banco de dados. Isso garante que uma série de operações de banco de dados possam ser tratadas como uma única unidade atômica, completadas inteiramente ou não, mantendo assim a consistência e a confiabilidade dos seus dados.
$ db -> transaction -> begin ();
$ db -> transaction -> commit ();
$ db -> transaction -> rollback ();Esse recurso é particularmente útil em cenários onde diversas operações de banco de dados relacionadas precisam ser executadas juntas. Se alguma operação dentro da transação falhar, o método rollback pode ser usado para reverter todas as alterações feitas desde o início da transação, evitando assim atualizações parciais que poderiam levar a inconsistências de dados. Por outro lado, se todas as operações forem bem-sucedidas, o método commit salvará todas as alterações no banco de dados.
Utilizando esses controles de transação, o PHP-DbHandler garante que o gerenciamento de dados do seu aplicativo seja robusto, consistente e resistente a erros. Esteja você lidando com entradas de dados complexas, atualizações ou processos em lote, esses recursos transacionais fornecem as ferramentas necessárias para gerenciar suas operações de banco de dados de maneira eficaz.
A classe Transaction também apresenta um recurso poderoso para gerenciar cenários de transações complexas. Esse recurso permite controlar globalmente as confirmações de transação, especialmente útil quando você deseja abranger vários métodos que usam transações em um contexto transacional único e abrangente.
Lidando com transações globalmente
Você pode gerenciar diversas operações transacionais como parte de uma transação maior desabilitando confirmações automáticas. Isto é particularmente útil em cenários onde diversas operações, cada uma capaz de lidar com transações de forma independente, precisam ser executadas como parte de uma única transação atômica.
// Begin a transaction
$ db -> transaction -> begin ();
// Disable automatic commits
$ db -> transaction -> setCommitsModeOff ();
// Execute other methods that use transactions
// $db->transaction->begin();
// ...
// $db->transaction->commit();
// Re-enable automatic commits
$ db -> transaction -> setCommitsModeOn ();
// Commit the transaction
$ db -> transaction -> commit ();Esse recurso aprimora o controle sobre as operações transacionais, permitindo cenários de manipulação de dados mais complexos e confiáveis. Ele garante que todas as alterações feitas no escopo da transação global sejam confirmadas em conjunto ou revertidas, mantendo a integridade e a consistência dos dados.
Valorizamos muito e recebemos contribuições para o projeto! Se você estiver interessado em contribuir, leia nosso arquivo CONTRIBUTING.md para obter informações detalhadas sobre como começar, diretrizes para enviar contribuições e dicas para tornar o processo o mais fácil e eficaz possível.
Esteja você corrigindo um bug, adicionando um recurso ou melhorando a documentação, suas contribuições serão muito apreciadas e terão um impacto significativo no projeto.
Se você tiver dúvidas ou quiser discutir ideias antes de codificar, sinta-se à vontade para abrir um problema em nossa página de problemas do GitHub para discussão.
Agradecemos sua disposição em contribuir e aguardamos seus envios!
Esta biblioteca está licenciada sob a licença MIT. Consulte o arquivo LICENSE para obter mais detalhes.
Para obter suporte, visite a página de problemas no repositório GitHub: GitHub Issues
