Descargar php dbhandler - Descarga del código fuente php dbhandler

PHP-DbHandler

Estado de acción de CI GitHub

PHP-DbHandler es una biblioteca PHP diseñada para simplificar las interacciones con bases de datos MySQL. Ofrece un conjunto completo de herramientas para crear y ejecutar consultas, administrar transacciones y manejar esquemas de bases de datos a través de conexiones PDO.

Contenido

Características
Instalación
Configuración
Crear cláusulas Where y Having
- Operadores de comparación
- Operadores lógicos
- or y and operadores
Crear y ejecutar consultas
- SELECCIONAR
- INSERTAR
- ACTUALIZAR
- BORRAR
- PROCEDIMIENTOS ALMACENADOS
Actas
- Gestión de transacciones globales
Contribuyendo
- Proceso de contribución
- Usando el contenedor de desarrollo
- Pruebas con plagas
- Envío de contribuciones
- Proceso de revisión
- Preguntas y discusiones
Licencia
Apoyo

Características

Creación de consultas : cree fácilmente consultas SQL utilizando una sintaxis fluida e intuitiva.
Gestión de transacciones : maneje de manera eficiente las transacciones de bases de datos con soporte integrado.
Gestión de esquemas : administre cómodamente el esquema de la base de datos, incluidas tablas y procedimientos almacenados.
Integración de caché : aproveche el almacenamiento en caché de los resultados de las consultas para mejorar el rendimiento.
Registro y manejo de errores : Registro integrado y manejo de errores para una mejor depuración y monitoreo.
Cumplimiento de los estándares PSR : cumple con los estándares PSR, lo que garantiza un código PHP interoperable y de alta calidad.

Instalación

Instale el paquete a través de Composer:

composer require tribal2/db-handler

Configuración

Comience creando una instancia 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
);

Crear cláusulas `Where` y `Having`

La clase Where proporciona una forma flexible e intuitiva de construir condiciones de consulta. Admite una variedad de operadores lógicos y de comparación, lo que le permite definir con precisión los criterios para seleccionar o filtrar datos de su base de datos.

Los métodos devuelven un objeto Where que encapsula la condición, junto con un valor parametrizado para realizar consultas seguras y eficientes.

Las cláusulas Where no sólo simplifican la construcción de la sintaxis de consulta sino que también mejoran la seguridad al gestionar internamente los riesgos asociados con la inyección SQL. Esta biblioteca reemplaza automáticamente los valores con parámetros con nombre PDO y realiza la vinculación utilizando los tipos de datos PDO apropiados. Al manejar estos aspectos cruciales, se garantiza que sus consultas no solo sean limpias y fáciles de mantener, sino también seguras.

Ya no tendrá que preocuparse por desinfectar manualmente sus entradas para consultas de bases de datos. La biblioteca se encarga de preparar las declaraciones de manera que protejan contra la inyección SQL, una de las vulnerabilidades de seguridad más comunes en las aplicaciones basadas en bases de datos. Este enfoque le permite centrarse en la lógica empresarial de su aplicación, confiando en que las interacciones de la base de datos se manejan de forma segura y eficiente.

Operadores de comparación

 $ 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

Operadores lógicos

 $ 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` y `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)

También puede anidar operadores or and :

 $ where3 = Where:: equals ( ' category ' , ' archived ' );
$ combinedWhere = Where:: and ( $ where3 , $ orWhere );
// Output: (`category` = :category___1 AND (`status` = :status___1 OR `price` > :price___1))

Crear y ejecutar consultas

En las siguientes subsecciones, exploraremos cómo crear y ejecutar consultas utilizando esta biblioteca. En aras de la simplicidad, asumiremos que la variable $db es una instancia de la clase Db .

En todos los ejemplos siguientes, separamos la construcción de la consulta de la ejecución. Este enfoque le permite reutilizar el objeto de consulta y ejecutarlo varias veces con diferentes parámetros, pero también puede encadenar los métodos para crear y ejecutar la consulta en una sola declaración como esta:

 $ results = $ db
  -> select ()
  -> columns ([ ' column1 ' , ' column2 ' ])
  -> from ( ' table_name ' )
  -> where (Where:: equals ( ' column2 ' , 1 ))
  -> fethAll ();

SELECCIONAR

 $ 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;

Obteniendo resultados:

De forma predeterminada, el método fetchAll() devuelve una matriz de objetos (usando PDO::FETCH_OBJ de forma predeterminada), donde cada objeto representa una fila de datos. También puede obtener los resultados como una matriz de matrices asociativas pasando la constante PDO::FETCH_ASSOC como argumento al método constructor fetchMethod() antes de ejecutar la 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)
// }

También puedes recuperar el recuento de resultados con:

 $ countResults = $ select -> fetchCount ();
// Output: 5

Paginación:

Manejar eficientemente grandes conjuntos de datos y proporcionar una interfaz fácil de usar para la navegación de datos son esenciales para cualquier aplicación sólida. La función de paginación en PHP-DbHandler aborda estas necesidades con elegancia. Simplifica el proceso de dividir sus datos en fragmentos manejables o "páginas", lo que facilita el trabajo con grandes conjuntos de datos sin abrumar al sistema ni al usuario.

Configurar la paginación

Hay dos formas de configurar la paginación para sus consultas:

Uso del método paginar: este método le permite definir la cantidad de elementos por página de manera concisa. Es una forma eficaz de preparar su consulta para la paginación.
```
 $ select = $ db -> select ()
  -> from ( ' table_name ' )
  // ...
  -> paginate (itemsPerPage: 10 );
```
Establecer manualmente el límite y el desplazamiento: para tener más control, puede especificar manualmente el límite (número de elementos por página) y el desplazamiento (punto de partida en el conjunto de datos) para su consulta.
```
 $ select = $ db -> select ()
  -> from ( ' table_name ' )
  // ...
  -> limit ( 10 )
  -> offset ( 0 );
```

Obteniendo resultados con paginación

Una vez configurada la paginación, puede obtener resultados de varias maneras, navegando por su conjunto de datos con facilidad:

fetchPage(?int $page) : recupera una página actual o específica.
fetchNextPage() : recupera resultados para la página siguiente.
fetchPreviousPage() : recupera los resultados de la página anterior.
fetchFirstPage() : recupera resultados de la primera página.
fetchLastPage() : recupera resultados de la última página.

Cada uno de estos métodos devuelve un objeto FetchPaginatedResult , que contiene las siguientes propiedades:

data : una matriz de registros en la página actual.
count : el número total de registros en el conjunto de datos.
page : El número de página actual.
perPage : el número de registros por página.
totalPages : el 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 paginación en PHP-DbHandler garantiza que pueda administrar y navegar de manera efectiva a través de grandes conjuntos de datos, mejorando el rendimiento general y la experiencia del usuario de su aplicación.

Almacenamiento en caché:

En las aplicaciones actuales basadas en datos, la eficiencia y el rendimiento son clave. Para mejorar estos aspectos en las interacciones de la base de datos, la biblioteca incluye una función de almacenamiento en caché dentro de sus consultas Select . Esta característica aumenta el rendimiento al almacenar en caché los resultados de las consultas, lo que reduce la carga de la base de datos y mejora los tiempos de respuesta para las consultas ejecutadas con frecuencia. Es importante destacar que está diseñado para cumplir totalmente con el estándar PSR-16 (Simple Cache), lo que garantiza una amplia compatibilidad y flexibilidad.

Almacenamiento en caché compatible con PSR-16
La funcionalidad de almacenamiento en caché dentro de las consultas Select acepta cualquier instancia de caché que implemente PsrSimpleCacheCacheInterface. Este cumplimiento de los estándares PSR-16 significa que puede integrar sin problemas una amplia gama de bibliotecas de almacenamiento en caché que se adhieren a esta interfaz, ofreciéndole la flexibilidad de elegir la solución de almacenamiento en caché que mejor se adapte a las necesidades de su aplicación.

Configuración de caché : si se proporciona una instancia de PsrSimpleCacheCacheInterface al inicializar la clase Db , puede omitir este paso. Si no lo hiciste, puedes usar el método setCache :

 $ select = $ db -> select ()-> setCache ( $ simpleCacheInstance );

Notas:
Si no proporcionó una instancia de caché al inicializar la clase Db , debe configurarla para cada consulta Select que desee almacenar en caché.
También puede utilizar este método si desea configurar una instancia de caché específica para una consulta Select . Esto le permite utilizar diferentes soluciones de almacenamiento en caché para diferentes consultas, según las necesidades de su aplicación.

Configuración de caché : habilite y configure el almacenamiento en caché para su consulta utilizando el método withCache . Puede especificar un valor de retorno predeterminado para las entradas de caché que faltan y un TTL (tiempo de vida) para los datos almacenados en caché.

 $ select -> withCache (defaultValue, ttl);

Notas:
El argumento defaultValue es opcional. Si no se proporciona, la biblioteca devolverá NULL por las entradas de caché que faltan.
El argumento ttl es opcional. Si no se proporciona, la biblioteca utilizará el valor TTL establecido por la instancia PsrSimpleCache.

Manejo automatizado de caché : al ejecutar una consulta con el almacenamiento en caché habilitado, la biblioteca primero verifica la presencia de resultados almacenados en caché. Si está disponible, lo recupera del caché, omitiendo la consulta de la base de datos. De lo contrario, ejecuta la consulta, almacena en caché el resultado y luego lo devuelve.

 $ allResults = $ select -> fetchAll ();
$ firstResult = $ select -> fetchFirst ();
$ column1Values = $ select -> fetchColumn ( ' column1 ' );
$ column3DistinctValues = $ select -> fetchDistincts ( ' column3 ' );

Beneficios clave

Flexibilidad : elija entre una variedad de implementaciones de almacenamiento en caché que cumplan con PSR-16.
Rendimiento : reduzca la frecuencia de las consultas a la base de datos utilizando datos almacenados en caché para consultas repetidas.
Facilidad de uso : la implementación del almacenamiento en caché es sencilla y se integra sin problemas con las estructuras de consulta existentes.
Generación confiable de claves de caché : la biblioteca genera claves de caché únicas para cada consulta, lo que garantiza la precisión y relevancia de los datos almacenados en caché.

INSERTAR

La clase Insert en la biblioteca PHP-DbHandler agiliza el proceso de creación y ejecución de consultas de inserción en una base de datos. Esta clase, equipada con múltiples características e interfaces, ofrece un enfoque sofisticado para manejar operaciones de inserción con varias características avanzadas.

Generación de consultas

Asignación dinámica de valores : la clase Insert le permite asignar valores dinámicamente a las columnas para su inserción. Puede agregar un valor único o varios valores a la vez:

 $ insert = $ db -> insert ()
  -> into ( ' table_name ' )
  -> value ( ' column1 ' , ' value1 ' )
  -> values ([ ' column2 ' => ' value2 ' , ' column3 ' => ' value3 ' ]);

La clase verificará si la columna existe en la tabla antes de agregar el valor y también se encargará del enlace PDO necesario.

Insertar varias filas : inserte varias filas a la vez sin esfuerzo proporcionando una matriz de valores:

 $ rows = [
  [ ' column1 ' => ' value1 ' , ' column2 ' => ' value2 ' ],
  [ ' column1 ' => ' value3 ' , ' column2 ' => ' value4 ' ],
  // ...
];
$ insert -> rows ( $ rows );

Ejecución

 $ success = $ insert -> execute ();

cheques
Antes de ejecutar una operación de inserción, la clase verificará automáticamente:
Si la base de datos está en modo de solo lectura , se evitan operaciones de escritura no deseadas.
Si hay colisiones en claves primarias que no son de incremento automático , se garantiza la integridad de los datos.

La clase Insert es una solución integral para manejar operaciones de inserción en una base de datos, que ofrece facilidad de uso y características avanzadas para administrar tareas de inserción complejas de manera eficiente.

ACTUALIZAR

La clase Update de la biblioteca PHP-DbHandler proporciona una forma sofisticada y flexible de construir y ejecutar consultas de actualización en una base de datos. Está diseñado para integrarse perfectamente con la estructura de la base de datos existente y, al mismo tiempo, ofrece funciones sólidas para gestionar las operaciones de actualización de forma eficaz.

Generación de consultas

Configuración de valores de actualización : especifique fácilmente las columnas que se actualizarán y sus nuevos valores. La clase garantiza que solo se actualicen las columnas existentes, lo que evita errores y mantiene la integridad de los datos.

 $ 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 ' ));

Ejecución

 $ success = $ update -> execute ();

Verificación del modo de solo lectura : antes de la ejecución, la clase verifica si la base de datos está en modo de solo lectura, evitando así operaciones de escritura no deseadas.

La clase Update representa una solución integral para construir y ejecutar operaciones de actualización en una base de datos. Su combinación de flexibilidad, robustez y facilidad de uso lo convierte en una opción ideal para administrar actualizaciones de bases de datos en aplicaciones PHP.

BORRAR

La clase Delete en la biblioteca PHP-DbHandler ofrece un enfoque sofisticado para construir y ejecutar consultas de eliminación en bases de datos. Esta clase garantiza que las operaciones de eliminación se realicen con precisión y seguridad, integrando comprobaciones y funciones esenciales para un manejo óptimo de las consultas.

Generación de consultas

La clase permite seleccionar con precisión los registros que se eliminarán mediante expresiones condicionales. Esto se logra mediante el método where , que permite seleccionar filas específicas para su eliminación según los criterios dados.

 $ delete = $ db -> delete ()
  -> from ( ' table_name ' )
  -> where (Where:: equals ( ' column ' , ' value ' ));

Cláusula Where obligatoria : para evitar la eliminación accidental de todos los registros de una tabla, la clase requiere que se especifique una cláusula WHERE . Esto sirve como protección contra eliminaciones masivas no intencionadas.

Ejecución

 $ success = $ delete -> execute ();

La clase realiza comprobaciones esenciales antes de ejecutar la operación de eliminación, incluida la verificación de la existencia de la tabla y la garantía de que la base de datos no esté en modo de solo lectura.

La clase Delete está diseñada para manejar operaciones de eliminación con un alto grado de control y seguridad. Garantiza que las eliminaciones se realicen con precisión, respetando la estructura y las restricciones de la base de datos. Ya sea que esté realizando tareas de eliminación simples o complejas, esta clase proporciona las herramientas necesarias para ejecutarlas de manera confiable y segura.

PROCEDIMIENTOS ALMACENADOS

La clase StoredProcedure en la biblioteca PHP-DbHandler ofrece un enfoque simplificado y eficiente para ejecutar procedimientos almacenados en bases de datos. Esta clase proporciona una forma sólida de interactuar con procedimientos almacenados, manejando la gestión de parámetros, la ejecución y la obtención de resultados con facilidad.

Generación de consultas

Configuración de llamadas a procedimientos almacenados : configure fácilmente llamadas a procedimientos almacenados con gestión dinámica de parámetros. Especifique el nombre del procedimiento y los parámetros que requiere.

 $ procedure = $ db -> storedProcedure ()
  -> call ( ' procedure_name ' )
  -> with ( ' paramName ' , $ value )
  // ...
  -> with ( ' paramName2 ' , $ value );

Ejecución

 $ results = $ procedure -> execute ();

Comprobaciones del modo de solo lectura : antes de la ejecución, la clase verifica si la base de datos está en modo de solo lectura, asegurando que las operaciones de escritura no se realicen involuntariamente.

La clase StoredProcedure es una herramienta indispensable para manejar llamadas a procedimientos almacenados dentro de aplicaciones PHP. Simplifica la interacción con los procedimientos almacenados, haciendo que el proceso sea más intuitivo y menos propenso a errores, especialmente en aplicaciones que dependen en gran medida de operaciones complejas de bases de datos.

Actas

La gestión de transacciones de bases de datos es un aspecto crucial para garantizar la integridad de los datos, especialmente en aplicaciones que tratan con manipulación de datos compleja. PHP-DbHandler simplifica este proceso y ofrece una forma intuitiva y sencilla de manejar transacciones.

Con las capacidades de gestión de transacciones proporcionadas, puede iniciar, confirmar o revertir transacciones fácilmente, lo que le brinda un control total sobre las operaciones de su base de datos. Esto garantiza que una serie de operaciones de base de datos puedan tratarse como una sola unidad atómica, ya sea que se completen por completo o no se completen en absoluto, manteniendo así la coherencia y confiabilidad de sus datos.

 $ db -> transaction -> begin ();
$ db -> transaction -> commit ();
$ db -> transaction -> rollback ();

Esta característica es particularmente útil en escenarios donde es necesario ejecutar juntas varias operaciones de bases de datos relacionadas. Si falla alguna operación dentro de la transacción, se puede utilizar el método de reversión para revertir todos los cambios realizados desde el comienzo de la transacción, evitando así actualizaciones parciales que podrían provocar inconsistencias en los datos. Por el contrario, si todas las operaciones tienen éxito, el método de confirmación guardará todos los cambios en la base de datos.

Al utilizar estos controles de transacciones, PHP-DbHandler garantiza que la gestión de datos de su aplicación sea sólida, consistente y resistente a errores. Ya sea que esté tratando con entradas de datos complejas, actualizaciones o procesos por lotes, estas capacidades transaccionales brindan las herramientas necesarias para administrar las operaciones de su base de datos de manera efectiva.

Gestión de transacciones globales

La clase Transaction también presenta una característica poderosa para administrar escenarios de transacciones complejos. Esta característica le permite controlar globalmente las confirmaciones de transacciones, lo que es especialmente útil cuando desea abarcar múltiples métodos que utilizan transacciones bajo un contexto transaccional único y general.

Manejo de transacciones a nivel mundial

Puede gestionar múltiples operaciones transaccionales como parte de una transacción más grande desactivando las confirmaciones automáticas. Esto es particularmente útil en escenarios donde es necesario ejecutar varias operaciones, cada una de ellas capaz de manejar transacciones de forma independiente, como parte de una única transacción 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 ();

Esta característica mejora el control sobre las operaciones transaccionales, permitiendo escenarios de manipulación de datos más complejos y confiables. Garantiza que todos los cambios realizados dentro del alcance de la transacción global se confirmen juntos o se reviertan, manteniendo la integridad y coherencia de los datos.

Contribuyendo

¡Valoramos mucho y agradecemos las contribuciones al proyecto! Si está interesado en contribuir, lea nuestro archivo CONTRIBUTING.md para obtener información detallada sobre cómo comenzar, pautas para enviar contribuciones y consejos para hacer que el proceso sea lo más fácil y efectivo posible.

Ya sea que esté corrigiendo un error, agregando una característica o mejorando la documentación, sus contribuciones son muy apreciadas y tienen un impacto significativo en el proyecto.

Preguntas y discusiones

Si tiene preguntas o desea discutir ideas antes de codificar, no dude en abrir un problema en nuestra página de Problemas de GitHub para su discusión.

¡Apreciamos su disposición a contribuir y esperamos sus envíos!

Licencia

Esta biblioteca tiene la licencia MIT. Consulte el archivo de LICENCIA para obtener más detalles.

Apoyo

Para obtener ayuda, visite la página de problemas en el repositorio de GitHub: Problemas de GitHub

Expandir

php dbhandler

PHP-DbHandler

Contenido

Características

Instalación

Configuración

Crear cláusulas `Where` y `Having`

Operadores de comparación

Operadores lógicos

`or` y `and` operadores

Crear y ejecutar consultas

SELECCIONAR

INSERTAR

ACTUALIZAR

BORRAR

PROCEDIMIENTOS ALMACENADOS

Actas

Gestión de transacciones globales

Contribuyendo

Preguntas y discusiones

Licencia

Apoyo

stripe php

PHPCsv

QCMS PHP

QCMS PHP

QCMS PHP

QCMS PHP

chat.petals.dev

GPT Prompt Templates

GPTyped

termwind

wp functions

slugify

waymo open dataset

termwind

wp functions

php dbhandler

PHP-DbHandler

Contenido

Características

Instalación

Configuración

Crear cláusulas Where y Having

Operadores de comparación

Operadores lógicos

or y and operadores

Crear y ejecutar consultas

SELECCIONAR

INSERTAR

ACTUALIZAR

BORRAR

PROCEDIMIENTOS ALMACENADOS

Actas

Gestión de transacciones globales

Contribuyendo

Preguntas y discusiones

Licencia

Apoyo

Crear cláusulas `Where` y `Having`

`or` y `and` operadores