Anexsoft | Blog y dictado de cursos de Tecnología

En este encontrarás tutoriales de tecnología como PHP, ASP.NET MVC, Front-End, entre otros y cursos exigentes de modalidad online que te ayudarán a crecer profesionalmente.

Ejemplo de SQLite con PHP y PDO
Actualizado el 04 Mayo, 2017 y leído 2,118 veces
Calificación: Sin calificar 10

Ejemplo de SQLite con PHP y PDO

Anexsoft

El objetivo de esta lección es crear un ejemplo muy sencillo que nos permita crear una base de datos SQLite, realizar una importación mediante CSV y listar los usuarios.

 

¿Qué es SQLite?

Es una base de datos empotrada o anidada a nuestro aplicativo, esto quiere decir que su finalidad es que solo sirva para la aplicación que lo quiera usar y es ideal cuando no contamos con mucho hardware o necesito una DB para un aplicativo pequeño como podría ser una aplicación de mobile o una app web simple como un CMS ligero. Basicamente, se va a generar un archivo con extensión .sqlite en nuestro proyecto, eso es nuestra base de datos y contiene toda la información.

 

¿Qué necesito para trabajar con SQLite y PHP?

Pues tener habilitado el módulo de SQLite para PDO y crear una clase base para conectarnos a nuestra db.

<?php
namespace App\Util;

use PDO, PDOException;

class DbContext {
    private static $db = null;

    public static function initialize() {
        if(empty(self::$db)) {
            try {
                self::$db = new PDO('sqlite:database.sqlite');
                self::$db->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
                self::$db->setAttribute(PDO::ATTR_DEFAULT_FETCH_MODE, PDO::FETCH_OBJ);
            } catch (PDOException $e) {
                die($e->getMessage());
            }
        }
    }

    public static function getInstance() {
        return self::$db;
    }
    
    public static function generateSchema() {
        $command = '
        CREATE TABLE IF NOT EXISTS users (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            name VARCHAR(100) NOT NULL,
            last_name VARCHAR(100) NOT NULL,
            address VARCHAR(100) NOT NULL,
            telephone VARCHAR(100) NOT NULL,
            cellphone VARCHAR(100) NOT NULL,
            avatar VARCHAR(100) NOT NULL
        )';

        try {
            self::$db->exec($command);
        } catch (PDOException $e) {
            die($e->getMessage());
        }
    }
}

Esta clase hace 2 cosas:

  • La primera crear la instancia de PDO y darnos acceso.
  • La segunda generar el Schema de nuestra base de datos.

¿Creo que se entiende bastante no?, este es el código mágico que permite realizar la conexión a nuestra db de SQLite.

public static function initialize() {
    if(empty(self::$db)) {
        try {
            self::$db = new PDO('sqlite:database.sqlite');
            self::$db->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
            self::$db->setAttribute(PDO::ATTR_DEFAULT_FETCH_MODE, PDO::FETCH_OBJ);
        } catch (PDOException $e) {
            die($e->getMessage());
        }
    }
}

Este archivo va a ser ejecutado desde nuestra consola corriendo el comando php import.php

¿Y ahora?

Ahora vamos a crear un archivo de migración que será el encargado de generar el esquema y este archivo debería ser corrido una sola vez.

<?php
require_once __DIR__ . '/app/util/DbContext.php';
require_once __DIR__ . '/app/model/User.php';
require_once __DIR__ . '/app/service/UserService.php';

use App\Util\DbContext,
    App\Service\UserService;

DbContext::initialize();
print '- Instanciando la base de datos';

DbContext::generateSchema();
print PHP_EOL . '- Generado la esquema';

UserService::importFromCsv(
    __DIR__ . '/users.csv'
);

print PHP_EOL . '- Importando CSV';

print PHP_EOL . sprintf('- Se han importado %s usuarios', UserService::count());
print PHP_EOL . '- Proceso finalizado';

No te preocupes si no entiendes todo el código voy a compartir el GitHub.

 

¿Y luego?

Luego solo nos queda crear nuestra clase para hacer las consultas SQL

<?php
namespace App\Service;

use App\Util\DbContext,
    App\Util\Anexgrid,
    App\Model\User,
    PDOException,
    PDO;


class UserService {
    public static function importFromCsv($file) {
        $users = [];

        $isFirstLine = true;

        if (($gestor = fopen($file, "r")) !== FALSE) {
            while (($datos = fgetcsv($gestor, 1000, "|")) !== FALSE) {
                if(!$isFirstLine) {
                    $user = new User();
                    $user->name = $datos[0];
                    $user->lastName = $datos[1];
                    $user->address = $datos[2];

                    $phones = explode('-', $datos[3]);
                    $user->telephone = $phones[0];
                    $user->cellphone = isset($phones[1]) ? $phones[1] : '';

                    $user->avatar = 'images/' . $datos[4];

                    $users[] = $user;
                } else {
                    $isFirstLine = false;
                }
            }

            fclose($gestor);
        }

        foreach($users as $user) {
            try {
                DbContext::initialize();
                $qry = DbContext::getInstance()->prepare(
                    'INSERT INTO users (name, last_name, address, telephone, cellphone, avatar) VALUES (?, ?, ?, ?, ?, ?)'
                );

                $qry->execute([
                    $user->name,
                    $user->lastName,
                    $user->address,
                    $user->telephone,
                    $user->cellphone,
                    $user->avatar
                ]);
            } catch (PDOException $e) {
                die($e->getMessage());
            }
        }
    }

    public static function getAll() {
        try
        {
            DbContext::initialize();

            /* AnexGRID */
            $anexgrid = new AnexGrid();

            /* Los registros */

            $sql = "
                SELECT * FROM users
                ORDER BY $anexgrid->columna $anexgrid->columna_orden
                LIMIT $anexgrid->pagina, $anexgrid->limite
            ";

            $pdo = DbContext::getInstance();

            $stm = $pdo->prepare( $sql );
            $stm->execute();

            $result = $stm->fetchAll(PDO::FETCH_OBJ);

            /* El total de registros */
            $total = $pdo->query("
                SELECT COUNT(*) Total
                FROM users
            ")->fetchObject()->Total;

            return $anexgrid->responde($result, $total);
        }
        catch(Exception $e)
        {
            die($e->getMessage());
        }
    }

    public static function count() {
        try {
            DbContext::initialize();
            $qry = DbContext::getInstance()->prepare(
                'SELECT COUNT(*) total FROM users'
            );
            $qry->execute();
            return $qry->fetchColumn();
        } catch (PDOException $e) {
            die($e->getMessage());
        }
    }
}

 

¿Una forma más fácil de trabajar esto?

Generar el esquema completo por código sería algo tedioso para un proyecto que requiera más tablas, bien, existe un IDE para SQLite que se llama DB Browser SQLite y pueden generar todo el esquema como si se tratará de Mysql Workbench o SQL Server Managment Studio, es decir desde una interfaz gráfica. Simplemente el programa te pedirá donde quieres guardar la DB y ya, pues con esto tendríamos resuelto todo. Ahora si quieres crear un archivo base que levante la DB desde cero el programa te permite generar un script SQL de creación, este lo podrías guardar en tu proyecto y hacer un execute script (investigar porque no se como se hace pero debe ser muy fácil jaja).

 

¿Cómo pruebo el ejemplo?

Bien les estoy comportiendo el GitHub, les voy a explicar los pasos que deben hacer para ejecutar el proyecto

  • Abrir su consola y posicionarse en el proyecto
  • Ejecutar el comando composer update
  • Ejecutar el comando php import.php para generar el esquema de la base de datos, el archivo database.sqlite e insertar data en nuestra tabla.
  • Desde su browser favorito abrir el proyecto y disfrutar
  • Compartir la publicación y contarle al mundo sobre el pequeño pueblo llamado Anexsoft

¡Adquiera ya!

  • Software de Portafolio Profesional hecho en ASP.NET MVC 5 C#

    Software de Portafolio Profesional hecho en ASP.NET MVC 5 C#
  • Código de fuente de Red Social desarrollada en ASP.NET MVC

    Código de fuente de Red Social desarrollada en ASP.NET MVC
  • Software de Venta e Inventario hecho en PHP y Codeigniter

    Software de Venta e Inventario hecho en PHP y Codeigniter

Últimas publicaciones

Encuesta

¿Sobre qué te gustaría que se hable más?

Síguenos

Estudia con nosotros y crece profesionalmente

Nuestros cursos han sido hecho en base a lo que demanda el mercado hoy en día.
La experiencia obtenida es la de un ambiente laboral.

Anexsoft
© 2017 Anexsoft, blog y cursos online de TI.