Definición

Oracle Database es un sistema de gestión de base de datos objeto-relacional (u ORDBMS por el acrónimo en inglés de Object-Relational Data Base Management System), desarrollado por Oracle Corporation.

Oracle es básicamente una herramienta cliente/servidor para la gestión de Bases de Datos. Es un producto vendido a nivel mundial, aunque la gran potencia que tiene y su elevado precio hace que sólo se vea en empresas muy grandes y multinacionales, por norma general. En el desarrollo de páginas web pasa lo mismo: como es un sistema muy caro no está tan extendido como otras bases de datos, por ejemplo, Access, MySQL, SQL Server, etc. 

En el siguiente articulo de la universidad del valle se presentan algunas de las funciones básicas para iniciar a trabajar con esta herramienta

Iniciando con Oracle

Índice de contenido

• Ingresando a Oracle 
• Cambiando Su Contraseña 
• Ingresando un Comando SQL en SQL*Plus 
• Saliendo de SQL*Plus 
• Consiguiendo Ayuda 
• Creación de una Tabla 
• Inserción de Tuplas 
• Recuperando un valor de una Tabla 
• Actualizando Tuplas en una Tabla 
• Borrando Tuplas de una Tabla 
• Borrando Tablas
• Adicionando Comentarios
• Recuperando Información a Cerca de Su Base de Datos 

Ingresando a Oracle

Usted puede ingresar a Oracle tecleando:

sqlplus <suNombre>/<suPassword> @ictus

Aquí, el sqlplus es el nombre de la interfaz del SQL genérica. <suNombre> se refiere a la identificación como

usuario para el inicio de sesión. <suPassword> se refiere a la clave secreta para ingresar a Oracle. ictus se refiere a la máquina donde se trabaja el DBMS Oracle. Usted debe digitar su contraseña. Sugerimos que usted modifique su contraseña.

Cambiando Su Contraseña.

En el prompt SQL>, digite

alter user <suNombre> identified by <nuevoPassword>;

el donde < suNombre > es el código de usuario, y < nuevoPassword > es la contraseña que le gustaría usar en el

futuro. Este comando, como todos los demás comandos de SQL, debe terminarse con un punto y coma.

Verifique que Usted tiene los privilegios para modificar su password.

Ingresando un Comando SQL en SQL*Plus

Usted puede entrar su declaración de SQL en solo una línea o en varias líneas. Para terminar una instrucción del SQL y ejecutar, usted debe hacerlo digitando un punto y coma para finalizar la instrucción.

Saliendo de SQL*Plus
Para salir de la sesión SQL se digita en exit en el prompt:
SQL> exit

Consiguiendo Ayuda
Para solicitar ayuda a Oracle se digita en el prompt:
SQL> help index

Para solicitar ayuda sobre un comando particular se digita:

SQL> help <nombre del Comando>

Ejemplo:

SQL> help spool

Para empezar capturando la salida, digite spool salida.txt dónde salida.txt es el nuevo archivo de texto creado para almacenar lo que aparece en la pantalla.Para finalizar la captura, se digita spool off.

Creación de una Tabla

En el sqlplus podemos ejecutar cualquier orden de SQL. Un tipo simple de orden crea una tabla (o relación). La

sintaxis es

CREATE TABLE <NombreTabla> (

< la lista de atributos y sus tipos > );

Usted puede entrar el texto en una sola línea o en varias líneas. Si su comando usa varias líneas, aparecerá una línea numerada hasta que usted teclee el punto y coma que finaliza cualquier comando SQL. Advertencia: una

línea vacía termina el orden pero no la ejecuta. Un ejemplo:

SQL> create table Prueba ( i int, s char(10) );

Note que el SQL es el insensible a las mayúsculas, entonces CREATE TABLE y create table trabajan en igual forma. Este comando crea una tabla llamada Prueba con dos atributos. El primero i, es un entero, y el segundo s, es una cadena de caracteres de longitud (hasta) 10. Para crear una tabla que declara un atributo como llave primaria:

CREATE TABLE <NombreTabla> (..., a <type> PRIMARY KEY, b, ...);

Para crear una tabla que declara un conjunto de atributos (a, b, c) como llave primaria:

CREATE TABLE <NombreTabla> 

(<atributos y sus tipos>, 

PRIMARY KEY (a, b, c));

Inserción de Tuplas

Habiendo creado una tabla, podemos insertar tuplas en ella. La manera más simple de inserción es con el comando INSERT:

INSERT INTO <NombreTabla>

VALUES( <lista de valores para los atributos, en orden> );

Por ejemplo, nosotros podemos insertar la tupla (10, ``software '') en la tabla Prueba así:

SQL> INSERT INTO Prueba VALUES(10, “software”);

Recuperando un valor de una Tabla

Nosotros podemos ver las tuplas de una relación con el comando:

SELECT * FROM <NombreTabla> ;

Por ejemplo, después de la anterior creación e inserción, la orden, SELECT * FROM Prueba;

produce el resultado.

     I    S

---------- ----------

10  software

Actualizando Tuplas en una Tabla

Para actualizar una tabla de su base de datos, ejecute

UPDATE <NombreTabla> 

SET atributo = <nuevo valor> ... 

WHERE <condición>;

Ejemplo:

SQL> UPDATE Prueba SET s =”Otro Mazo “ WHERE i = 1;

Borrando Tuplas de una Tabla

Para borrar una tupla de una tabla se ejecuta

DELETE FROM <NombreTabla>

WHERE <condición>;

Ejemplo:

SQL> UPDATE Prueba SET s =”Otro Mazo “ WHERE i = 1;

Borrando Tablas

Para borrar una tabla de su base de datos, ejecute

DROP TABLE <NombreTabla> ;

Ejemplos:

SQL> DROP TABLE Prueba;

SQL> DROP TABLE Prueba cascade constraints;

Adicionando Comentarios

El Para incluir un comentario en SQL, las se debe iniciar la líneas hacen trampas el menos del doble (el guión de o--) que se extiende hasta el final de la línea.

Y cuando el comentario ocupa varias líneas se delimita entre /* y */.

Recuperando Información a Cerca de Su Base de Datos

El sistema guarda la información sobre su propia base de datos en ciertas tablas. La más importante por ahora es USER_TABLES. Usted puede recordar los nombres de sus tablas ejecutando la consulta:

SELECT TABLE_NAME

FROM USER_TABLES;

Más información sobre las tablas está disponible en esta relación. Para ver todos los atributos de TABLE_NAME,

intente:

SELECT *

FROM USER_TABLES;

También es posible recordar los atributos de una tabla una vez que usted conozca su nombre. Ejecute la orden:

DESCRIBE MiTabla;

Para listar las tablas que Usted ha construido en la base de datos se digita:

SQL> SELECT * FROM cat; (donde cat en el nombre de la tabla).

Para descargar la herramienta, les ofrezco el oracle 10g. Dado que es un poco pesado lo dividí en 4 partes, espero no tengan dificultades.

Parte 1. Aquí.

Esta primera parte la descargan y la instalan.  Este primer paquete se instala solo.

Luego descargan estas tres otras partes que son las mas pesadas y las unen, y también la instalan.

Parte 1 de 3.  Aquí.

Parte 2 de 3.  Aquí.

Parte 3 de 3.  Aquí.

Qué es la Normalización

La normalización es el proceso mediante el cual se transforman datos complejos a un conjunto de

estructuras de datos más pequeñas, que además de ser más simples y más estables, son más

fáciles de mantener. También se puede entender la normalización como una serie de reglas que sirven

para ayudar a los diseñadores de bases de datos a desarrollar un esquema que minimice los

problemas de lógica. Cada regla está basada en la que le antecede. La normalización se adoptó porque el

viejo estilo de poner todos los datos en un solo lugar, como un archivo o una tabla de la base de datos,

era ineficiente y conducía a errores de lógica cuando se trataban de manipular los datos.

La normalización también hace las cosas fáciles de entender. Los seres humanos tenemos la tendencia

de simplificar las cosas al máximo. Lo hacemos con casi todo, desde los animales hasta con los

automóviles. Vemos una imagen de gran tamaño y la hacemos más simple agrupando cosas similares

juntas. Las guías que la normalización provee crean el marco de referencia para simplificar una estructura

de datos compleja.

Otra ventaja de la normalización de base de datos es el consumo de espacio. Una base de datos

normalizada ocupa menos espacio en disco que una no normalizada. Hay menos repetición de datos, lo

que tiene como consecuencia un mucho menor uso de espacio en disco.

El proceso de normalización tiene un nombre y una serie de reglas para cada fase. Esto puede parecer

un poco confuso al principio, pero poco a poco se va entendiendo el proceso, así como las razones para

hacerlo de esta manera.

Grados de Normalización

Existen básicamente tres niveles de normalización: Primera Forma Normal (1NF), Segunda Forma

Normal (2NF) y Tercera Forma Normal (3NF). Cada una de estas formas tiene sus propias reglas.

Cuando una base de datos se conforma a un nivel, se considera normalizada a esa forma de

normalización. No siempre es una buena idea tener una base de datos conformada en el nivel más alto

de normalización, puede llevar a un nivel de complejidad que pudiera ser evitado si estuviera en un nivel

más bajo de normalización.

En la tabla siguiente se describe breve-mente en que consiste cada una de las reglas, y posteriormente

se explican con más detalle.

Tomada de www.mysql-hispano.org

Primera Forma Normal

La regla de la Primera Forma Normal establece que las columnas repetidas deben eliminarse y

colocarse en tablas separadas.

Poner la base de datos en la Primera Forma Normal resuelve el problema de los encabezados de

columna múltiples. Muy a menudo, los diseñadores de bases de datos inexpertos harán algo similar a

la tabla no normalizada. Una y otra vez, crearán columnas que representen los mismos datos. La

normalización ayuda a clarificar la base de datos y a organizarla en partes más pequeñas y más

fáciles de entender. En lugar de tener que entender una tabla gigantesca y monolítica que tiene

muchos diferentes aspectos, sólo tenemos que entender los objetos pequeños y más tangibles, así

como las relaciones que guardan con otros objetos también pequeños.

Segunda Forma Normal

La regla de la Segunda Forma Normal establece que todas las dependencias parciales se deben

eliminar y separar dentro de sus propias tablas. Una dependencia parcial es un término que describe a

aquellos datos que no dependen de la llave primaria de la tabla para identificarlos.

Una vez alcanzado el nivel de la Segunda Forma Normal, se controlan la mayoría de los problemas de

lógica. Podemos insertar un registro sin un exceso de datos en la mayoría de las tablas.

Tercera Forma Normal

Una tabla está normalizada en esta forma si todas las columnas que no son llave son funcionalmente

dependientes por completo de la llave primaria y no hay dependencias transitivas. Comentamos

anteriormente que una dependencia transitiva es aquella en la cual existen columnas que no son llave

que dependen de otras columnas que tampoco son llave.

Cuando las tablas están en la Tercera Forma Normal se previenen errores de lógica cuando se insertan

o borran registros. Cada columna en una tabla está identificada de manera única por la llave primaria,

y no deben haber datos repetidos. Esto provee un esquema limpio y elegante, que es fácil de trabajar y

expandir.

Un dato sin normalizar no cumple con ninguna regla de normalización. Para explicar con un ejemplo en

que consiste cada una de las reglas, vamos a considerar los datos de la siguiente tabla.

Tomada de www.mysql-hispano.org

Al examinar estos registros, podemos darnos cuenta que contienen un grupo repetido para NUM_ITEM,

DESC_ITEM, CANT y PRECIO. La 1FN prohibe los grupos repetidos, por lo tanto tenemos que

convertir a la primera forma normal. Los pasos a seguir son:

» Tenemos que eliminar los grupos repetidos.

» Tenemos que crear una nueva tabla con la PK de la tabla base y el grupo repetido.

Los registros quedan ahora conformados en dos tablas que llamaemos ORDENES y

ARTICULOS_ORDENES.

Ahora procederemos a aplicar la segunda formal normal, es decir, tenemos que eliminar cualquier

columna no llave que no dependa de la llave primaria de la tabla. Los pasos a seguir son:

» Determinar cuáles columnas que no son llave no dependen de la llave primaria de la tabla.

» Eliminar esas columnas de la tabla base.

Crear una segunda tabla con esas columnas y la(s) columna(s) de la PK de la cual dependen.

La tabla ORDENES está en 2FN. Cualquier valor único de ID_ORDEN determina un sólo valor para

cada columna. Por lo tanto, todas las columnas son dependientes de la llave primaria ID_ORDEN.

Por su parte, la tabla ARTICULOS_ORDENES no se encuentra en 2FN ya que las columnas PRECIO y

DESC_ITEM son dependientes de NUM_ITEM, pero no son dependientes de ID_ORDEN. Lo que

haremos a continuación es eliminar estas columnas de la tabla ARTICULOS_ORDENES y crear una

tabla ARTICULOS con dichas columnas y la llave primaria de la que dependen.

Las tablas quedan ahora de la siguiente manera.

Tomada de www.mysql-hispano.org

La tercera forma normal nos dice que tenemos que eliminar cualquier columna no llave que sea

dependiente de otra columna no llave. Los pasos a seguir son:

» Determinar las columnas que son dependientes de otra columna no llave.

» Eliminar esas columnas de la tabla base.

 Crear una segunda tabla con esas columnas y con la columna no llave de la cual son

dependientes.

Al observar las tablas que hemos creado, nos damos cuenta que tanto la tabla ARTICULOS, como la

tabla ARTICULOS_ORDENES se encuentran en 3FN. Sin embargo la tabla ORDENES no lo está, ya

que NOM_CLIENTE y ESTADO son dependientes de ID_CLIENTE, y esta columna no es la llave

primaria.

Para normalizar esta tabla, moveremos las columnas no llave y la columna llave de la cual dependen

dentro de una nueva tabla CLIENTES. Las nuevas tablas CLIENTES y ORDENES se muestran a

continuación.

Tomada de www.mysql-hispano.org

¿Qué tan lejos debe llevar la normalización?

La siguiente decisión es ¿qué tan lejos debe llevar la normalización? La normalización es una ciencia

subjetiva. Determinar las necesidades de simplificación depende de nosotros. Si nuestra base de datos

va a proveer información a un solo usuario para un propósito simple y existen pocas posibilidades de

expansión, normalizar los datos hasta la 3FN quizá sea algo exagerado. Las reglas de normalización

existen como guías para crear tablas que sean fáciles de manejar, así como flexibles y eficientes. A

veces puede ocurrir que normalizar los datos hasta el nivel más alto no tenga sentido.

¿Se están dividiendo tablas sólo para seguir las reglas o estas divisiones son en verdad prácticas?.

Éstas son el tipo de cosas que nosotros como diseñadores de la base de datos, necesitamos decidir, y

la experiencia y el sentido común nos pueden auxiliar para tomar la decisión correcta. La normalización

no es una ciencia exacta, más bien subjetiva.

Existen seis niveles más de normalización que no se han discutido aquí. Ellos son Forma Normal BoyceCodd, Cuarta Forma Normal (4NF), Quinta Forma Normal (5NF) o Forma Normal de Proyección-Unión,

Forma Normal de Proyección-Unión Fuerte, Forma Normal de Proyección-Unión Extra Fuerte y Forma

Normal de Clave de Dominio. Estas formas de normalización pueden llevar las cosas más allá de lo

que necesitamos. Éstas existen para hacer una base de datos realmente relacional. Tienen que ver

principalmente con dependencias múltiples y claves relacionales.

En conclusión 

La normalización es una técnica que se utiliza para crear relaciones lógicas apropiadas entre tablas de

una base de datos. Ayuda a prevenir errores lógicos en la manipulación de datos. La normalización facilita

también agregar nuevas columnas sin romper el esquema actual ni las relaciones.

Existen varios niveles de normalización: Primera Forma Normal, Segunda Forma Normal, Tercera Forma

Normal, Forma Normal Boyce-Codd, Cuarta Forma Normal, Quinta Forma Normal o Forma Normal de

Proyección-Unión, Forma Normal de Proyección-Unión Fuerte, Forma Normal de Proyección-Unión Extra

Fuerte y Forma Normal de Clave de Dominio. Cada nuevo nivel o forma nos acerca más a hacer una

base de datos verdaderamente relacional.

Se discutieron las primeras tres formas. Éstas proveen suficiente nivel de normalización para cumplir con

las necesidades de la mayoría de las bases de datos. Normalizar demasiado puede conducir a tener una

base de datos ineficiente y hacer a su esquema demasiado complejo para trabajar. Un balance

apropiado de sentido común y práctico puede ayudarnos a decidir cuándo normalizar.

Vídeo de youTube que profundiza.

Me permito  dejarles el link de descarga del articulo de donde fue tomado, ya que el articulo no es de mi auto-ria.

Descarga el articulo. Aquí 

Para esta sencillas demostración, en donde el resultado final va hacer una ventana implementando la herencia, utilizaremos el IDE JCreator o si desean ejecutarlo en otro editor, por ejemplo Netbeans, solo creen las clases con sus respectivos nombres y la podran ejecutar.

Primero que todo vamos ver un poco de teoría, esto nos ayudara a ser mas claros y comprender mejor todo este asunto de programación. Voy a explicarles un poco de los componentes Swing de java que donde nos enfocaremos en este articulo.

Componentes de Swing

Componentes contenedores (sirven para contener y organizar otros componentes):

Controles Básicos  en java

CONTROLES ESPECIALIZADOS

Controles no interactivos (muestran algún tipo de información pero no interaccionan con el usuario)

                                        

     

Captura de eventos

•          Para la captura de eventos Swing usa un esquema a similar a los callbacks pero utilizando clases en lugar de funciones

•          Cada clase de captura de eventos (denominados event listeners) debe implementar una interfaz concreta en función del tipo de eventos que desea capturar

•          Una vez implementado el listener, bastará con indicar éste al componente del cual deseamos capturar los eventos

           Existen ciertos event listeners que son comunes a todos los componentes:

·         FocusListener: captura eventos relacionados con la recepción o pérdida del foco

·         KeyListener: captura pulsaciones de teclado sobre el componente activo

·         MouseListener: captura la entrada o salida del cursor sobre un componente, así como pulsaciones de los botones

·         MouseMotionListener: captura movimientos del ratón sobre el componente

         Otros son específicos de algunos componentes:

·         ActionListener: captura cierto tipo de acción realizada sobre ciertos componente.

Por ejemplo, pulsar un botón, seleccionar un elemento en una lista desplegable o una opción en un menú

·         ChangeListener: registra los cambios sobre ciertos componente. Por ejemplo un cambio en el dato de un spinner, o un nuevo valor seleccionado en un slider

·         ItemListener: recoge el cambio de estado en un componente tipo on/off: check boxes, radio buttons y listas desplegables

·         ListSelectionListener: es un listener específico para detectar las selecciones múltiples realizadas en listas y tablas

·         WindowListener: permite recoger los eventos relacionados con las ventanas (cerrar,minimizar, maximizar, iconizar, etc.) en los frames, frames internos y cuadros de diálogo

Ejemplo de Herencia Aplicando interfaz gráfica

Implementaremos en una ventana que contiene 5 campos los cuales nos permitirá capturar datos desde unas cajas de texto, capturarlas en un objeto y posteriormente mostrarla si así lo deseamos.

Comencemos con la primera clase.

public class Persona {

            private String dir, nom, ape;

            private int eda;

            public Persona( )

            {}

            public Persona( String mape,String mnom, String mdir, int meda ) {

                        asignarEda(meda);

                        asignarApe(mape);

                        asignarNom(mnom);

                        asignarDir(mdir);          

            }

   

    public void asignarEda(int meda){eda=meda;}

    public void asignarApe(String mape){ape=mape;}

    public void asignarDir(String mdir){dir=mdir;}

    public void asignarNom(String mnom){nom=mnom;}

   

    public int obtenerEda(){return eda;}

    public String obtenerApe(){return ape;}

    public String obtenerDir(){return dir;}

    public String obtenerNom(){return nom;}

    }

Después crear la clase persona o como ustedes la quieran llamar, codificamos la clase alumno, la cual hereda de la clase persona:

public class Alumno extends Persona{

            String esp;

            public Alumno()

            {}

    public Alumno(String mape,String mnom, String mdir, int meda, String mesp) {

            super(mape, mnom,  mdir,  meda);

            asignarEsp(mesp);

    }

   

    public void asignarEsp(String mesp){esp=mesp;}

    public String obtenerEsp(){return esp;}

}

Por último crear la clase ventana, para interactuar con el objeto instan-ciado de la clase alumno. A su vez programar los eventos asociados a los botones registrar y consultar, definida en la siguiente clase Ventana heredando de la clase JFrame (básica para diseño de la interfaz) y haciendo uso de la la clase ActionListener para activar los eventos sobre los botones definidos en la interfaz. Como se puede ver ha  continuación:

import java.awt.*;
import javax.swing.*;
import java.awt.event.*;

public class Ventana extends JFrame implements ActionListener
{
JPanel JP1,JP2, JPF1,JPF2,JPF3;
JButton B1,B2,B3;
JLabel E1;
JTabbedPane tabbedPane;
JTextField c1,c2,c3,c4,c5;
Alumno x=new Alumno();

    public Ventana() 
    {   E1 = new JLabel("Swing");
    B1 = new JButton("Registrar");
    B2 = new JButton("Consultar");
    B3 = new JButton("Salir");
   
    JP1 = new JPanel();
    JP2 = new JPanel();
    
    JPF1 = new JPanel();
    JPF2 = new JPanel();
    tabbedPane = new JTabbedPane();
   
    JLabel l1=new JLabel("Apellido");
c1 =new JTextField(20);
JLabel l2=new JLabel("Nombre");
c2=new JTextField(20);
JLabel l3=new JLabel("Direccion");
c3 =new JTextField(30);
JLabel l4=new JLabel("Edad");
c4 =new JTextField(5);
JLabel l5=new JLabel("Profesion");
c5 =new JTextField(20);

JPF1.setLayout(new BoxLayout(JPF1,BoxLayout.PAGE_AXIS));

JPF1.add(l1);
JPF1.add(c1);
JPF1.add(l2);
JPF1.add(c2);
JPF1.add(l3);
JPF1.add(c3);
JPF1.add(l4);
JPF1.add(c4);
JPF1.add(l5);
JPF1.add(c5);

tabbedPane.addTab("Persona",null,JPF1,  "Datos Personales");

   
    JP1.setLayout(new FlowLayout(FlowLayout.CENTER));
    JP1.add(tabbedPane);
   
    JP2.setLayout(new FlowLayout(FlowLayout.CENTER));
    JP2.add(B1);
    JP2.add(B2);
    JP2.add(B3);
   
    
    getContentPane().setLayout(new BoxLayout(getContentPane(),BoxLayout.PAGE_AXIS));
   
    getContentPane().add(E1);
    getContentPane().add(JP1);
    getContentPane().add(JP2);
   
           
B1.addActionListener(this);
B2.addActionListener(this);
B3.addActionListener(this);


pack();
//setSize (300,120);
    setVisible(true);
    setTitle("Programaion Orientada a Objetos");
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    this.setLocationRelativeTo (null);
   this.setResizable (false);
//repaint();   
    }
     public static void main(String args[])
    {
   Ventana p =new Ventana();
   p.setVisible (true); 
  
       
    }
    
    
    public void limpiar()
    {c1.setText("");
     c2.setText("");
     c3.setText("");
     c4.setText("");
     c5.setText("");
    }
    
    public void cargar()
    {
    c1.setText(x.obtenerApe());
    c2.setText(x.obtenerNom());
    c3.setText(x.obtenerDir());
    c4.setText(String.valueOf(x.obtenerEda()));
    c5.setText(x.obtenerEsp());
    }
    
    public void actionPerformed(ActionEvent e)
    {
   
    if (e.getSource()==B1)
    {   if (tabbedPane.getSelectedIndex()==0)
    { x.asignarApe(c1.getText());
    x.asignarNom(c2.getText());
    x.asignarDir(c3.getText());
    x.asignarEda(Integer.parseInt(c4.getText()));
    x.asignarEsp(c5.getText());
    limpiar();
        }
    }
    
    if (e.getSource()==B2)
    {
      cargar();
               
    }

  
    if (e.getSource()==B3)
    {          
         System.exit(0);
    }   
   
    } 


}
Link descarga: Aquí