Un día oí

… a alguien decir “Si te caes siete veces, levántate ocho”

Modificando tablas mediante SQL (DDL).

Como complemento al artículo donde explicábamos cómo crear tablas mediante DDL en SQL, en este artículos explicaremos cómo modificar las tablas que hayamos creado previamente en un espacio de trabajo.

Para modificar una tabla en SQL, nos ayudamos del comando ALTER TABLE . El formato general será el siguiente:

ALTER TABLE nombre_tabla {acción_modificar_columna | acción_modificar_restricción_tabla};

es decir , ALTER TABLE seguido del nombre de la tabla a modificar y a continuación acciones que irán enfocadas a modificar una columna, añadir y/o modificar restricciones o modificar una tabla.

Las acciones destinadas a modificar columnas son las siguientes:

• Añadir columnas : ADD (columna def_columnas [, columna2 def_columnas …] ).
  • Ejemplo: ALTER TABLE COCHE ADD (caballos NUMBER(3))
• Borrar columnas: DROP (columna [, columna2 def_columnas, …] )
  • Ejemplo: ALTER TABLE COCHE DROP (motor NUMBER(20))
• Modificar columnas: MODIFY (columna def_columnas [, columna2 def_columnas …] )
  • Ejemplo: ALTER TABLE COCHE MODIFY (motor NUMBER(20)) .
  • Lógicamente la columna ha de estar creada con anterioridad, las opciones que Oracle nos permite modificar son:
    • Incrementar la precisión o anchura de los tipos de datos
    • Sólo se puede reducir la anchura, si esa columna posee nulo en todos los registros, todos los valores son tan pequeños como la nueva anchura o no hay registros.
• Renombrar columnas: RENAME COLUMN nombreAntiguo TO nombreNuevo .                                                                        Ejemplo:  ALTER TABLE COCHE RENAME COLUMN combustible TO tipoCombustible.

Las acciones enfocadas a modificar las restricciones son las siguientes:

• Añadir restricciones: ADD [CONSTRAINT nombre] tipoDeRestricción(columnas)
  • Ejemplo:  ALTER TABLE COCHE ADD CONSTRAINT COCHE_PK PRIMARY KEY (matricula). Añadiría a la tabla Coche la restricción de nombre COCHE_PK ,de tipo PRIMARY KEY referente a la columna matrícula.
  • El tipo de Restricción puede ser:
    • CHECK : Para restringir los valores de la columna a los que definamos nosotros.
    • PRIMARY KEY: Para indicar que es clave primaria.
    • FOREIGN KEY: Para indicar que es clave ajena.
• Borrar restricciones:  DROP PRIMARY KEY | UNIQUE (campos) | CONSTRAINT nombreRestricción. Es decir DROP seguido de PRIMARY KEY para borrar una clave primaria , UNIQUE con los campos que deseemos o CONSTRAINT y nombre de restricción para borrar una restricción en concreto.
  • Ejemplo: ALTER TABLE COCHE DROP PRIMARY KEY
  • Ejemplo: ALTER TABLE COCHE DROP CONSTRAINT COCHE_CHK
• Desactivar restricciones: DISABLE CONSTRAINT nombre Para desactivar restricciones previamente creadas.
  • Ejemplo: ALTER TABLE COCHE DISABLE CONSTRAINT COCHE_CHK .
• Activar restricciones: ENABLE CONSTRAINT nombre . Para activar restricciones previamente creadas y desactivadas.
  • Ejemplo: ALTER TABLE COCHE ENABLE CONSTRAINT COCHE_CHK
• Renombrar restricciones: RENAME CONSTRAINT nombreViejo TO nombreNuevo. Para cambiar el nombre de una restricción previamente creada.
  • Ejemplo: ALTER TABLE COCHE RENAME CONSTRAINT COCHE_CHK TO COMBUSTIBLE_CHK

Las acciones destinadas a modificar una tabla son las siguientes:

• Borrar una tabla: DROP TABLE nombre_tabla. Al borrar una tabla tenemos que tener en cuenta que el borrado es irreversible, desapareciendo los datos que tenía, aunque prevalecen las vistas y los sinónimos referentes a esa tabla, siendo conveniente eliminarlos posteriormente. Lógicamente sólo podremos borrar tablas si tenemos permisos para ello.
  • Ejemplo: DROP TABLE conductor.
• Renombrar una tabla: RENAME nombreViejo TO nombreNuevo. Cambia el nombre de una tabla previamente creada de un nombre antiguo a uno nuevo.
  • Ejemplo: RENAME conductor TO conductores.
• Borrar el contenido de una tabla: TRUNCATE TABLE nombreTabla. Borra los datos de la tabla sin borrar la tabla.
  • Ejemplo: TRUNCATE TABLE conductores.

Un día oí

… a alguien decir “No tenía miedo a las dificultades: lo que la asustaba era la obligación de tener que escoger un camino. Escoger un camino significaba abandonar otros.”

Uso práctico de Interfaz en Java. Visibilidad de métodos.

Un uso común de las interfaces en Java es cuando quieres tener accesibilidad pública a algún método o atributo de una clase que , por cuestiones de diseño, tiene visibilidad privada o de paquete.

Para ilustrar ésto, en el siguiente ejemplo tenemos la clase Conductor dentro de la clase Coche, ambas dentro del paquete cursojava.Coche:

package cursojava;
public class Coche {

private String marca;
private String modelo;
private Conductor conductor;
public Coche(String marca, String modelo) {
this.marca = marca;
this.modelo = modelo;
conductor = new Conductor("Fernando Alonso");
}
public Conductor getConductor() {
return conductor;
}
public String getMarca() {
return marca;
}
public String getModelo() {
return modelo;
}

// la clase conductor solo tiene accesibilidad en clases que estén en el mismo paquete
class Conductor{
private String nombre;
public Conductor(String nombre) {
this.nombre = nombre;
}
public String getNombre() {
return nombre;
}
public void setNombre(String nombre) {
this.nombre = nombre;
}
}

Desde la clase Principal, ubicada en el paquete cursojava.principal, no podemos acceder al método getNombre de la clase conductor dado que no es accesible al estar en paquetes distintos.

package cursojava.principal;
import cursojava.Coche;
public class Principal {
public static void main(String[] args) {
Coche coche = new Coche("Ferrari", "F10");
//Tanto si intentamos acceder a getConductor creando un nuevo objeto
//de la clase conductor
Conductor conductor = coche.getConductor();
//Como  si lo hacemos llamando al atributo conductor de coche
String nombre = coche.getConductor().getNombre();
//nos será imposible acceder al método getnombre
System.out.println(conductor.getNombre());
}
}

Para solucionar este problema nos ayudaremos de un interfaz, que podemos definir en cualquier paquete, teniendo que importarlo si lo definiéramos en otro. Por ejemplo, en nuestro caso crearemos un Interfaz llamado IConductor ubicado en el paquete cursojava.interfaz y lo importaremos en los otros paquetes.

El interfaz lo definiremos de la siguiente forma:

package cursojava.interfaz;
public interface IConductor {
public String getNombre();
}

Y el resto de clases quedarán como sigue (observar los comentarios):

package cursojava;
import cursojava.interfaz.IConductor;
public class Coche {
private String marca;
private String modelo;
private Conductor conductor;

public Coche(String marca, String modelo) {
this.marca = marca;
this.modelo = modelo;
conductor = new Conductor("Fernando Alonso");
}

public Conductor getConductor() {
return conductor;
}

public String getMarca() {
return marca;
}

public String getModelo() {
return modelo;
}
}

// Ahora la clase Conductor implementa al Interface IConductor

class Conductor implements IConductor{
private String nombre;

public Conductor(String nombre) {
this.nombre = nombre;
}

//Debemos de implementar el método getNombre del Interfaz

public String getNombre() {
return nombre;
}

public void setNombre(String nombre) {
this.nombre = nombre;
}

}

package cursojava.principal;
import cursojava.Coche;
import cursojava.interfaz.IConductor;

public class Principal {

public static void main(String[] args) {
Coche coche = new Coche("Ferrari", "F10");
//Ahora accedemos por medio del Interfaz IConductor al método getConductor
IConductor conductor = coche.getConductor();
System.out.println(conductor.getNombre());
}
}

Un día oí

… a alguien decir “Todos somos muy ignorantes. Lo que ocurre es que no todos ignoramos las mismas cosas.”

Ejemplo de creación de tablas mediante SQL (DDL).

En este post llevaremos a la práctica todo lo dicho en la entrada donde se explicaba la creación de tablas con DLL.

Para ello crearemos las tablas necesarias para modelizar el siguiente diagrama entidad-relación básico para una empresa de una empresa mayorista:

CREATE TABLE CLIENTE (
DNI VARCHAR2(10),
&lNOMBRE VARCHAR2(20),
FECHA_NAC DATE NOT NULL,
TFNO VARCHAR2(10),
APELLIDOS VARCHAR2(100),
CONSTRAINT CLIENTE_PK PRIMARY KEY (DNI)
)
CREATE TABLE PROVEEDOR(
NIF VARCHAR2(10),
NOMBRE VARCHAR2(20),
DIRECCION VARCHAR2(200),
CONSTRAINT PROVEEDOR_PK PRIMARY KEY (NIF)

)

CREATE TABLE PRODUCTO(
NOMBRE VARCHAR2(50),
CODIGO VARCHAR2(50),
PRECIO NUMBER(10) NOT NULL,
PRV_NIF VARCHAR2(10),
CONSTRAINT PRODUCTO_PK PRIMARY KEY (CODIGO),
CONSTRAINT PROVEEDOR_FK FOREIGN KEY(PRV_NIF) REFERENCES PROVEEDOR (NIF)
)

CREATE TABLE CLIENTE_PRODUCTO(
PRD_CODIGO VARCHAR(50),
CLN_DNI VARCHAR(10),
CONSTRAINT CLIENTE_PRODUCTO_PK PRIMARY KEY (PRD_CODIGO, CLN_DNI),
CONSTRAINT PRODUCTOCP_FK FOREIGN KEY (PRD_CODIGO) REFERENCES PRODUCTO(CODIGO),
CONSTRAINT CLIENTECP_FK FOREIGN KEY (CLN_DNI) REFERENCES CLIENTE(DNI)
)

Creación de tablas mediante SQL (DDL)

Como sabemos DDL (Data Definition  Language) es la parte de lenguaje SQL encargado de realizar la función de definición de datos, así pues compondrán el conjunto de instrucciones SQL que permiten definir o borrar objetos de base de datos tales como tablas o vistas.

Es importante tener en cuenta que ninguna instrucción DDL puede ser anulada, por lo que hay que tener mucha precaución a la hora de utilizarlas. Es decir, las instrucciones DDL son definitivas.

En este artículo abordaremos la parte de DDL encargada de definir las tablas de las bases de datos.

El formato general para crear una tabla será el siguiente:

CREATE TABLE nombre_tabla(
definición_columna
[, definición_columna...]
[, restricciones_tabla]);

El proceso que hay que seguir para crear una tabla es:

• Lo primero es decidir que nombre queremos ponerle a la tabla (nombre_tabla). Para dar el nombre deberemos de tener en cuenta que:
  • Deben comenzar con una letra
  • No deben tener más de 30 caracteres
  • Sólo se permiten utilizar letras del alfabeto, número o elsigno de subrayado.
  • No puede haber dos tablas con el mismo nombre para el mismo esquema.
  • No pueden coincidir con el nombre de una palabra reservada SQL.
• Después, iremos dando el nombre de cada uno de los atributos que formarán las columnas de la tabla (nombre_columna). A cada una de las columnas le asignaremos un tipo de datos predefinido o bien un dominio definido por el usuario. También podremos dar definiciones por defecto y restricciones de columna. En esta parte nuestra definición tendrá el siguiente formato:

nombre_columna {tipo_datos} [def_defecto] [restric_col]

Los tipos de datos que se pueden utilizar son:

La opción def_defecto nos permite especificar qué nomenclatura queremos dar a nuestros valores por omisión.

Por ejemplo, para un empleado que todavía no se ha decidido cuánto ganará, podemos elegir que, de momento, tenga un sueldo de 0 euros (DEFAULT 0.0), o bien que tenga un sueldo con un valor nulo (DEFAULT NULL).

Sin embargo, hay que tener en cuenta que si elegimos la opción DEFAULT NULL, la columna para la que daremos la definición por defecto de valor nulo debería admitir valores nulos.

La opción DEFAULT tiene el siguiente formato:

DEFAULT (literal|null)

Las restricciones que se pueden dar son las que aparecen en la tabla que tenemos a continuación:

• Una vez definidas las columnas, sólo nos quedará dar las restricciones de tabla, según la tabla que se muestra a continuación:

Interfaces

Las interfaces son el máximo exponente del polimorfismo. Son equivalentes a una clase completamente abstracta, es decir, con todos sus métodos  abstractos (sin cuerpo).

Se declaran con la palabra reservada (“interface”). El interface puede tener datos y su forma general será como sigue:

public interface NombreInterfaz{
// datos  constantes
// métodos (sólo signatura)
}

Los métodos se declaran de forma normal (sin “abstract”) y definen la signatura a implementar en las clases que implementen la interfaz. Las clases pueden implementar todas las interfaces que quieran.

Los interfaces no heredan, se implementan, de tal forma que cuando cree una clase que implemente un interfaz base utilizaré  la palabra reservada “implements”.

public class ClaseConInterfaz implements NombreInterfaz

Ejemplo de interfaz:

public interface Figura {
//dato constante
public final Color COLOR = Color.BLUE;
/**método sin "abstract" que define como deberán de implementarlos la clase que implemente
la interfaz**/
public double volumen();
}
public class Cubo implements Figura
{
private float arista;
public Cubo(float arista){
this.arista = arista;
}
/** La clase implementa el método conforme ha sido definido previamente
en el interfez (mismo nombre y tipos de datos)**/
public double volumen() {
return Math.pow(arista, 3);
}
}

public class Tablero
{
public static void main(String[] args) {
Cubo cubo = new Cubo(6.23);
Color color = Cubo.COLOR;
System.out.println("Volumen: " + cubo.volumen());
}
}

Clases Abstractas

Las clases abstractas se definen por medio de la palabra reservada “abstract”. Son clases inacabadas y como tales  no se puede instanciar. Están pensadas para representar conceptos abstractos. Su única finalidad es que otras clases hereden de ellas, proporcionando los atributos y métodos que serán compartidos por todas sus clases derivadas.

Sirven para poder implementar conceptos que no deban existir físicamente.

Los métodos pueden declararse con la palabra reservada “abstract” y éstos metodos se caracterizan porque no pueden tener cuerpo.

public abstract void metodo();

Además de métodos abstractos una clase puede contener otro tipo de métodos, eso sí una clase con al menos un método abstracto, debe declararse abstracta.

Un posible ejemplo podría ser:

public abstract class Geometria{
private Color color;
/**Se define un metodo abstracto sin cuerpo, posteriormente
son implementados gracias al polimorfismo en las clases derivadas**/
public abstract double perimetro();  
public abstract double area();
//Puede contener métodos no abstractos como getColor
public Color getColor() { return color; } 
} 

public class Cuadrado extends Geometria{ 
private float lado; 
public Cuadrado(float lado) { this.lado = lado; }
/**para cada instanciación se define el método 
abstracto de la clase super**/
public double area() {  return lado*lado; }
/**para cada instanciación se define el método 
abstracto de la clase super**/
public double perimetro() {  return 4*lado; } }  
public class Lienzo{  public static void main(String[] args) { 
Cuadrado cuadrado = new Cuadrado(4.52); 
System.out.println("Area: " + cuadrado.area()); 
System.out.println("Perimetro: " + cuadrado.perimetro());   
} 
} 

Polimorfismo

El polimorfismo es una característica de la POO aplicable a los métodos que permite ejecutar un código de método distinto según el objeto que se haya instanciado y referenciado. Para que se de en Java se necesita que exista:

• 
  Relación de herencia.
• 
  Exactamente la misma signatura de método en ambas clases (padre e hija).

Se puede redefinir cualquier método salvo aquellos que sean “final” o “static”.

Se puede acceder a un método de la superclase que haya sido redefinido utilizando la palabra super.

// Método clase base
public int funcion()
// Método redefinido en la clase derivada
public int funcion()
// Acceso al método de la clase base
super.funcion()

Un ejemplo de polimorfismo podría ser:

//Clase super
public class Empleado
{
protected int sueldoBase = 700;
public int getSueldo() {
return sueldoBase;
}
}
//La clase Analista hereda a Empleado
public class Analista extends Empleado
{
//Y "polimorfea" getSueldo
public int getSueldo() {
return sueldoBase + 500;
}
}

//La clase Programador hereda a Empleado
public class Programador extends Empleado
{
//Y "polimorfea" getSueldo de forma distinta a Analista
public int getSueldo() {
return sueldoBase + 70;
}
}

Como sabemos cualquier clase que creamos en Java se hereda de la clase Object. De esta clase, los métodos que pueden ser redefinidos son:

• clone():  crea un objeto a partir de otro objeto de la misma clase.
• 
  equals(object):  indica si dos objetos son o no iguales. Devuelve true si son iguales.
• 
  toString():  devuelve un String conteniendo una representación del objeto como cadena de caracteres.

Por último comentar que el atributo “final” , si se indica en un método, no se podrá “polimorfear” ese método en clases derivadas:

class MiClase
{

public final void metodoNoPolimorfeable()
{ ...

Y si se indica en una clase, no se podrá heredar de dicha clase.

final class ClaseNoHeredable
{ ...

Por ejemplo, los tipos de datos básicos mapeados en clases son de tipo final.