New question

Question:

Date: 15-05-2018 16:07:20 (In Spanish)

Conexion php postgresql[Unresolved]

GRUPO E ACUDIDO A ESTE MEDIO PARA VER QUIEN ME PUEDE GUIAR EN LA CONEXION DE PHP CON POSTGRESQL CON UN EJEMPLO DE UN CRUD COMPLETO DE ANTEMANO AGRADECERÍA SU AYUDA Tags: Android - OOP - Opinion - PHP - PHP7 - PostgreSQL - Suggestion - The Community Votes: 0 - Answers: 6 - Views: 8 Share on: Google Facebook Twitter LinkedIn Link
 

Answers:

  • Date: 15-05-2018 16:27:31 Hola Freddy,
    Tienes dos opciones para conectarte. Puedes utilizar la librería nativa de PostgreSQL o utilizando PDO.

    Personalmente no utilizo la conexión nativa porque no es POO pero puedes crear un wrapper y no pasa nada.
    Prefiero PDO porque es POO y la flexibilidad que te da de cambiar de base de datos si así lo requirieras después.

    Qué has hecho de CRUD? En qué estás atorado?
      Votes: 3 - Link answer
     
  • Date: 15-05-2018 17:28:10 Hola Freddy.

    Te dejo una serie de videos que compone un video tutorial desarrollado por César Cancino en el cual trata el tema que has mencionado PHP POO, conexión de PostGreSQL con PDO. Creo que el último video desarrolla el CRUD.

    Videotutorial PHP y PostGreSQL



    Lista de los 7 videos.

    Espero que te Sirva.

    //PD No esta bien visto escribir todo en mayúsculas.

    Saludos.
      Votes: 2 - Link answer
     
  • Date: 15-05-2018 18:29:11 ¡Hola, Freddy Castro, bienvenido!

    He elaborado una clase para realizar la conexión y CRUD con la utilización de PDO (tal como recomienda Ernesto). Particionaré el código para ir explicando la clase y los métodos que conforman el CRUD pertenecientes a esta.

    Modelo PostgreSQL, la clase que compone la conexión y el CRUD. Para este CRUD jugaré con una base de datos que contiene una tabla usuarios.
    <?php
    	#Modelo principal de conexión y métodos de acción.
    	class PostgreSQL {
    		var $db; #Variable que representa la conexión a la DB.
    
    		#Método constructor que crea la conexión al servidor de base de datos.
    		#Gestor utilizado: PostgreSQL.
    		
    		/**
    			*@param: $host, $post, $dbase, $user, $pass.
    			*Se puede conectar con múltiples base de datos creando una nueva instancia.
    		*/
    
    		function __construct($host, $port, $dbase, $user, $pass){
    			#Escribir una cadena con formato de secuencia.
    			#fprintf(): http://php.net/manual/es/function.fprintf.php
    
    			$cn = sprintf("host=%s;port=%s;dbname=%s;user=%s;password=%s", 
    				$host, $port, $dbase, $user, $pass);
    
    			#Asignando la conexión a la variable local de este modelo: db.
    			if ($this->db = new PDO("pgsql:".$cn)){
    				$this->db->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION); 
    				#Se establecen atributos a la conexión.
    				#Más información: http://php.net/manual/es/pdo.setattribute.php	
    				
    				#Consulta que establece las entradas de texto a UTF-8.
    				if (@$this->db->query("SET NAMES 'utf8'"))
    					return true;
    			}
    
    			#Si algún paso ha sido fallido o incorrecto, se retorna un booleano falso.
    			return false;
    		}
            }

    Obtener todos los usuarios registrados.
    /**
    			* Método que obtiene la información de todos los usuarios.
    			*@param: No hay.
    		*/
    	    public function getUsers(){
    	    	#Statement: Consulta no preparada. 
    		    #Tabla: users.
    		    #Valores devueltos: Todos (*).
    
    	    	$stmt = $this->db->query("SELECT * FROM users;");
    
    	    	#Si existen registros.
    	    	if ($stmt->rowCount() > 0){
    	    		#Se define un array multidimensional.
    	    		$UsersData = [];
    
    	    		#Se recorren las filas devueltas.
    	    		while ($row = $stmt->fetch(\PDO::FETCH_ASSOC)){
    	    			#Se agrega la información en forma de atributo sobre los índices del array.
    	    			$UsersData[] = [
    	    				'username' 		=> $row['username'],
    	    				'email' 		=> $row['email'],
    	    				'date_log' 		=> $row['date_log'], 
    	    				'date_log_unix' => $row['date_log_unix'],
    	    				'privilege' 	=> $row['privilege']
    	    			];
    	    		}
    
    	    		#Se retorna el array de información.
    	    		return $UsersData;
    	    	}
    
    	    	#Si algo falla, se retorna un valor booleano falso.
    	    	return false;
    	    }

    Agregar o insertar un nuevo registro
    /**
    			* Método que agrega la información del nuevo usuario.
    			*@param: $usr (Nombre de usuario), $email (Dirección de correo), $privilege (Privilegios).
    		*/
    	    public function addUser($usr, $email, $privilege){
    	    	#Statement: Consulta preparada. 
    	    	#Tabla: users.
    	    	#Atributos: username, email, date_log, date_log_unix, privilege.
    	    	#Valores devueltos: Ninguno ya que se trata de insertar datos.
    
    	    	#Se alamacenan las instrucciones en esta variable.
    	    	$q = "INSERT INTO users (username, email, date_log, date_log_unix, privilege) VALUES (:username,:email,:date_log,:date_log_unix,:privilege);";
    	    
    	    	#Se prepara la consulta.
    	    	$stmt = $this->db->prepare($q);
    
    	    	#Se vincula un valor a un parámetro.
    	    	$stmt->bindValue(":username", 		$usr);
    	    	$stmt->bindValue(":email", 			$email);
    	    	$stmt->bindValue(":date_log", 		date('Y-n-j'));
    	    	$stmt->bindValue(":date_log_unix", 	time());
    	    	$stmt->bindValue(":privilege", 		$privilege);
    
    	    	#Se ejecuta la consulta preparada.
    	    	if ($stmt->execute())
    	    		return true; #Si se ha llegado hasta acá, es un resultado correcto.
    
    	    	#Si algo falla, se retorna un valor booleano falso.
    	    	return false;
    	    }

    Eliminar un registro
    /**
    			* Método que elimina un usuario.
    			*@param: $usr (Nombre de usuario).
    		*/
    	    public function deleteUser($usr){
    	    	#Statement: Consulta preparada. 
    	    	#Tabla: users.
    	    	#Atributos: username.
    	    	#Valores devueltos: Ninguno ya que se trata de eliminar datos.
    
    	    	#Hay que tener en cuenta que pueden existir otras tablas relacionadas con esta, sin embargo
    	    	#también son eliminadas ya que están escritas en cascada para actualizar y eliminar.
    	    	$Reason = $this->db->prepare('DELETE FROM users '
                    . 'WHERE username = :usr');
    
    	    	#Se vincula el valor con el parámetro.
            	$Reason->bindValue(':usr', $usr);
    
            	#Se habilitan las sesiones.
            	@session_start();
    
    	       	if ($Reason->execute())	#Se ejecuta la consulta preparada.
    	       		return true;	#Retorno verdadero si todo ha marchado bien.
    
    	       	#Si algo falla, se retorna un valor booleano falso.
            	return false;
    	    }

    Actualizar registro
    /**
    			* Método que actualiza el nombre de usuario de un usuario.
    			*@param: $new_usr (El nuevo nombre de usuario), $usr (Nombre de usuario al que hace referencia).
    		*/
    	    public function updateUser($new_usr, $usr){
    	    	#Statement: Consulta preparada. 
    	    	#Tabla: users.
    	    	#Atributos: username.
    	    	#Valores devueltos: Ninguno ya que se trata de actualizar datos.
    
    	    	#La actualización se hace en cascada con respecto a las demás tablas relacionadas a esta.
    	    	$Reason = $this->db->prepare('UPDATE users '
                    . 'SET username = :new_usr '
                    . 'WHERE username = :current_usr');
    
    	    	#Se vincula el valor con el parámetro.
            	$Reason->bindValue(':new_usr', $new_usr);
            	$Reason->bindValue(':current_usr', $usr);
    
            	if ($Reason->execute())	#Se ejecuta la consulta preparada.
    		    	return true;	#Todo el proceso ha sido correcto.
    
    		    #Si algo falla, se retorna un valor booleano falso.
    	    	return false;
    	    }

    Extraer la cantidad de registros en una tabla [Extra]
    /**
    			* Método que obtiene el número de usuarios que existen.
    			*@param: No hay.
    		*/
    	    public function getUserCount(){
    	    	#Statement: Consulta no preparada. 
    		    #Tabla: vip_user.
    		    #Atributos: -
    		    #Valores devueltos: Todos los posibles (*).
    
    	    	$stmt = $this->db->query("SELECT * FROM vip_user");
    	    	
    	    	#Se retorna la cantidad de filas devueltas por la consulta.
    	    	return $stmt->rowCount();
    	    }

    Ese fue un ejemplo de los métodos que debes agregar a la clase PostgreSQL.

    Implementación de la clase
    /**
    		* Función que conecta con el servidor de base de datos.
    		*@param: $db (Nombre de la base de datos).
    	*/
    	function ConnectDB($db){
    		#Retorno de la conexión. Escribir las credenciales correctas de conexión.
    		return new PostgreSQL("localhost", "3306", $db, "Usuario", "MiClave");
    	}
    
    	#Instancia del modelo PostgreSQL
    	$Instancia = ConnectDB("database_name");
    
    	#Implementación del CRUD
    	$Instancia->addUser($usr, $email, $privilege);
    	$Instancia->updateUser($new_usr, $usr);
    	$Instancia->deleteUser($usr);
    	$Instancia->getUsers();


    Cualquier duda, me la comentas.

    ¡Saludos!
      Votes: 2 - Link answer
     
  • Date: 16-05-2018 03:09:44 O podrías utilizar un ORM y te ahorras el esfuerzo además de que todo lo tendrías en objetos :)   Votes: 0 - Link answer
     
  • Date: 18-05-2018 04:13:09 Jerson,
    Tu ejemplo es bueno pero tiene algunos defectos como:
    - El uso de 'var' para propiedades es mala práctica y sólo aceptable para PHP4
    - Las propiedades nunca deben ser públicas (rompes la encapsulación)
    - Te falta declarar modificadores de acceso para todos los métodos
    - No usas PSR
    - Tus bloques de comentarios no siguen el estándar
    - Los constructores nunca deben regresar nada. Si algo sale mal deben arrojar una excepción.
    - Jamás debes utilizar el caracter '@' para ocultar mensajes de error a menos que sea una prueba
    - No es responsabilidad de la clase iniciar una sesión. Se viola el principio de Responsabilidad única.

    Lo corregí un poco para que veas de lo que hablo

    <?php
    /**
     * Modelo principal de conexión y métodos de acción.
     */
    class PostgreSQL
    {
        /**
         * Variable que representa la conexión a la DB.
         *
         * @var PDO
         */
        protected $conexion;
    
        /**
         * Método constructor que crea la conexión al servidor de base de datos.
         *
         * Se puede conectar con múltiples base de datos creando una nueva instancia.
         * Gestor utilizado: PostgreSQL.
         *
         * @param string $host
         * @param int    $port
         * @param string $dbase
         * @param string $user
         * @param string $pass
         */
        public function __construct($host, $port, $dbase, $user, $pass)
        {
            $stringConexion = 'pgsql:' . sprintf('host=%s;port=%s;dbname=%s;user=%s;password=%s',
                                                       $host, $port, $dbase, $user, $pass);
            $this->conexion = new PDO($stringConexion);
    
            $this->inicializa();
        }
    
        /**
         * Inicializa la conexión con algunas configuraciones por defecto
         *
         * @throws \RuntimeException
         *
         * @return bool
         */
        protected function inicializa()
        {
            $this->conexion->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
    
            /**
             * Se establecen atributos a la conexión.
             * Más información: http://php.net/manual/es/pdo.setattribute.php
             * Consulta que establece las entradas de texto a UTF-8.
             */
            if ($this->conexion->query("SET NAMES 'utf8'") === false) {
                throw new \RuntimeException('Fallo al configurar el set de caracteres');
            }
        }
    
        /**
         * Método que obtiene la información de todos los usuarios.
         *
         * @return array
         */
        public function getUsers()
        {
            $usersData = [];
            /**
             * Statement: Consulta no preparada.
             * Tabla: users.
             * Valores devueltos: Todos (*).
             */
            $stmt = $this->conexion->query('SELECT * FROM users');
            if ($stmt->rowCount() <= 0) {
                return $usersData;
            }
            /**
             * Si existen registros.
             * Se define un array multidimensional.
             * Se recorren las filas devueltas.
             */
            while ($row = $stmt->fetch(\PDO::FETCH_ASSOC)) {
                //Se agrega la información en forma de atributo sobre los índices del array.
                $usersData[] = $row;
            }
    
            return $usersData;
        }
    
        /**
         * Método que agrega la información del nuevo usuario.
         *
         * @param string $usr       Nombre de usuario
         * @param string $email     Dirección de correo
         * @param string $privilege Privilegio
         *
         * @return bool
         */
        public function addUser($usr, $email, $privilege)
        {
            /**
             * Statement: Consulta preparada.
             * Tabla: users.
             * Atributos: username, email, date_log, date_log_unix, privilege.
             * Valores devueltos: Ninguno ya que se trata de insertar datos.
             * Se almacenan las instrucciones en esta variable.
             */
            $consulta = 'INSERT INTO users (id, username, email, date_log, date_log_unix, privilege) ' .
                        'VALUES (NULL, :username, :email, :date_log, UNIX_TIMESTAMP(), :privilege)';
    
            //Se prepara la consulta.
            $stmt = $this->conexion->prepare($consulta);
    
            //Se vincula un valor a un parámetro.
            $stmt->bindValue(':username', $usr);
            $stmt->bindValue(':email', $email);
            $stmt->bindValue(':date_log', date('Y-m-d'));
            $stmt->bindValue(':privilege', $privilege);
    
            //Se ejecuta la consulta preparada.
            return $stmt->execute();
        }
    
        /**
         * Método que elimina un usuario.
         *
         * @param int $id Id de usuario
         *
         * @return bool
         */
        public function deleteUser($id)
        {
            /**
             * Statement: Consulta preparada.
             * Tabla: users.
             * Atributos: username.
             * Valores devueltos: Ninguno ya que se trata de eliminar datos.
             * Hay que tener en cuenta que pueden existir otras tablas relacionadas con esta, sin embargo
             * también son eliminadas ya que están escritas en cascada para actualizar y eliminar.
             */
            $reason = $this->conexion->prepare('DELETE FROM users WHERE id = :id');
    
            //Se vincula el valor con el parámetro.
            $reason->bindValue(':usr', $id);
    
            return $reason->execute();
        }
    
        /**
         * Método que actualiza el nombre de usuario de un usuario.
         *
         * @param int    $id       Id de usuario al que hace referencia
         * @param string $username El nuevo nombre de usuario
         *
         * @return bool
         */
        public function updateUser($id, $username)
        {
            /**
             * Statement: Consulta preparada.
             * Tabla: users.
             * Atributos: username.
             * Valores devueltos: Ninguno ya que se trata de actualizar datos.
             * La actualización se hace en cascada con respecto a las demás tablas relacionadas a esta.
             */
            $reason = $this->conexion->prepare('UPDATE users SET username = :new_usr ' .
                                               'WHERE id = :id');
    
            //Se vincula el valor con el parámetro.
            $reason->bindValue(':new_usr', $username);
            $reason->bindValue(':id', $id);
    
            return $reason->execute();
        }
    
        /**
         * Método que obtiene el número de usuarios que existen.
         *
         * @return int
         */
        public function getUserCount()
        {
            /**
             * Statement: Consulta no preparada.
             * Tabla: vip_user.
             * Atributos: -
             * Valores devueltos: Todos los posibles (*).
             */
            $stmt = $this->conexion->query('SELECT * FROM users');
    
            #Se retorna la cantidad de filas devueltas por la consulta.
            return $stmt->rowCount();
        }
    }
    
    /**
     * Función que conecta con el servidor de base de datos.
     *
     * @param string $db Nombre de la base de datos
     *
     * @return PostgreSQL
     */
    function ConnectDB($db)
    {
        //Retorno de la conexión. Escribir las credenciales correctas de conexión.
        return new PostgreSQL('localhost', 3306, $db, 'dbUser', 'p4s5w0rD!');
    }
    
    /**
     * Teniendo una base de datos:
     *
     * CREATE TABLE `users` (
     * `id` bigint(20) unsigned NOT NULL AUTO_INCREMENT,
     * `username` varchar(255) NOT NULL,
     * `email` varchar(255) NOT NULL,
     * `date_log` date NOT NULL,
     * `date_log_unix` bigint(20) unsigned NOT NULL,
     * `privilege` varchar(255) NOT NULL,
     * PRIMARY KEY (`id`),
     * UNIQUE KEY `username_idx` (`username`)
     * ) ENGINE=InnoDB DEFAULT CHARSET=latin1;
     */
    
    //Instancia del modelo PostgreSQL
    $Instancia = ConnectDB('database_name');
    //Implementación del CRUD
    $Instancia->addUser('Pepito', 'pepito@example.com', 'mortal');
    $Instancia->updateUser(1, 'NuevoPepito');
    $Instancia->deleteUser(1);
    $Instancia->getUsers();
    
    
      Votes: 1 - Link answer
     
  • Date: 18-05-2018 05:06:19 Excelente Ernesto, el repaso que me has dado, ha sido EXQUISITO. (+1)

    Uff, haz despertado en mí unas ganas tremendas de seguir aprendiendo sobre este lenguaje. Estoy de acuerdo con lo que pronuncias sobre las buenas prácticas, además de la estructura que le haz dado a la clase, está genial.

    Lo de las prácticas PSR, las conocí hasta hace algunos días, donde precisamente tú, la compartiste en un post en una crítica constructiva sobre un aporte de Walter. Lo de la sesión, olvidé quitarlo, este código lo tenía implementado en otro proyecto, así que para compartir con el colega, lo copie y lo intenté adaptar. Claramente, me tocará repasar OOP.

    Con toda sinceridad, agradezco mucho las correcciones.

    ¡Un saludo, Ernesto!
      Votes: 2 - Link answer
     
To actively participate in the community first must authenticate, enter the system.Sign In