Moviendo hacia otro tablespace tablas e índices en oracle

fuente http://gonzalo.aro.cl/blog/2010/07/07/moviendo-hacia-otro-tablespace-tablas-e-indices-en-oracle/

Moviendo hacia otro tablespace tablas e índices en oracle

Para mover una tabla y/o indice de un tablespace a otro se debe aplicar un ALTER como los siguientes

ALTER TABLE NOMBRE_ESQUEMA.NOMBRE_TABLA MOVE TABLESPACE NOMBRE_TABLESPACE;

ALTER INDEX NOMBRE_ESQUEMA.NOMBRE_INDICE REBUILD TABLESPACE NOMBRE_TABLESPACE;

Se puede utilizar un script (si tienes privilegios sobre las tablas) para poder armar este movimiento de tablas desde un esquema a otro. La primera selecciona toda la lista de tablas pertenecientes a un esquema y construye el SQL que ya fue mostrado. La seguna construye toda la tabla de indices.

select 'ALTER TABLE NOMBRE_ESQUEMA.' || table_name || ' MOVE TABLESPACE NOMBRE_TABLESPACE;' from all_tables whereowner = 'NOMBRE_ESQUEMA'




select 'ALTER INDEX NOMBRE_ESQUEMA.' || index_name || ' REBUILD TABLESPACE NOMBRE_TABLESPACE;' from all_indexeswhere table_owner = 'NOMBRE_ESQUEMA'










Si se requiere modificar un trigger 

Primero se dropea el trigger

Drop Trigger OWNER.TRIGGERNAME;

y despues de modificar la secuencia en el trigger se ejecuta el script para crear el trigger:

CREATE OR REPLACE TRIGGER "OWNER"."TRIGGERNAME" BEFORE

INSERT ON "OWNER"."TRIGGERNAME" FOR EACH ROW 

DECLARE

BEGIN

IF :NEW.SERIALKEY IS NULL THEN

SELECT OWNER.TRIGGERNAME

INTO   :NEW.SerialKey

FROM   dual;

     END IF;

END;








-----------------------------------------------------------------------
-- idices LOB
-----------------------------------------------------------------------


fuente http://cotosilva.blogspot.mx/2011/09/como-mover-un-indice-de-tipo-lob-un.html


Para los índices de tipo LOB que están asociados a una columna de la tabla, la cual fue creada con este tipo de segmento es necesario utilizar la siguiente consulta para determinar que índice debemos mover:

select 'alter table '||owner||'.'||table_name||' move '||chr(10)|| 'LOB ('||column_name||') store as '||'(tablespace TABLESPACE_DE_DESTINO);'
from dba_lobs
where owner ='ESQUEMA_A_MOVER';

Output:

alter table OWNER.TABLE_NAME move lob (COLUMNA_DE_TIPO_LOB) store as (tablespace TABLESPACE_DE_DESTINO);

Si no es utilizado este método para mover el índice de tipo LOB al nuevo tablespace, Oracle nos entrega el siguiente error:

ORA-02327: cannot create index on expression with datatype LOB


select 'alter table '||owner||'.'||table_name||' move '||chr(10)|| 'LOB ('||column_name||') store as '||'(tablespace MAP_IDX);'
from dba_lobs 
where owner ='MAP';










Java conexion a oracle 11g con jar

programa bajado de * @see Enlace: http://www.carpente.es/archivos/fic/opt/acs/jdbc.zip


import java.sql.*;
import oracle.jdbc.*;

/**
 * Programa de muestra para enseñar el uso de JDBC con bases de datos oracle.
 * <p>
 * Compilar: $ javac -classpath .:ojdbc6.jar EjemploJDBC.java
 *<p>
 * Ejecutar: $ java -classpath .:ojdbc6.jar EjemploJDBC
 * <p>
 * @author Adrián Carpente Recouso
 * @see Enlace: http://www.carpente.es/archivos/fic/opt/acs/jdbc.zip
 * En el siguiente en enlace podéis descargaros la presentacion vista en clase sobre JDBC.
 * @version Versión 1.0 - 16 Marzo del 2011
 */
public class EjemploJDBC
{
    //Datos para el acceso a la base de datos
    static String HOST = "X.X.X.X";
    static int PUERTO = 1521;
    static String SID = "Nombre";
    static String USUARIO = "usuario";
    static String CONTRASENA = "contraseña";


    /**
     * Método con el cual se cargan los divers de Oracle que hay en el fichero ojdbc6.jar.
     * En caso de no poder cargar los drivers se muestra por pantalla el motivo y
     * se detiene el programa.  
     */
    public static void cargarDriver()
    {
        try
        {
            //Cargarmos los drivers para manejar la base de datos.
            Class.forName("oracle.jdbc.driver.OracleDriver").newInstance();
        }
        catch(ClassNotFoundException e)
        {
            System.err.println("Drivers de Oracle no encontrados: " + e.getMessage());
            System.exit(0);
        }
        catch(IllegalAccessException e)
        {
            System.err.println("Acceso no permitido a los drivers de Oracle: " + e.getMessage());
            System.exit(0);
        }
        catch(InstantiationException e)
        {
            System.err.println("No se ha podido instanciar los drivers de Oracle: " + e.getMessage());
            System.exit(0);
        }
        catch(Exception e)
        {
            System.err.println("Error cargando los drivers de oracle: " + e.getMessage());
            System.exit(0);
        }
    }

    /**
     * Método que inicial la coñexión en la base de datos Oracle.
     * @param usuario Usuario de la base de datos. En las cuentas de la
     *                FIC es \"login\"
     * @param constrasena Contraseña de la base de datos. En las cuentas de la
     *                    FIC es tu DNI.
     * @param host Dominio o IP del servidor de base de datos. En la FIC es xurxo,
     *             en caso de no funcionar probar con xurxo.cc.fic.udc.es
     * @param puerto Puerto en el que está escuchando el servidor Oracle. En la
     *               FIC usan el 1521 que es el puerto por defecto de Oracle.
     * @param sid Identificador de la instancia de la base de datos. Se puede
     *            obtener desde un terminal ejecutando: $ echo $ORACLE_SID Para la
     *            versión Oracle Database 10g Express el identificador es XE. En
     *            las cuentas que tenemos creadas en la FIC el SID es docenciadb.
     * @return Una instancia de una conexión iniciada en la base de datos. Si se
     *         produce algún problema iniciando la conexión se muestra el error y
     *         devuelve null.
     */
    public static Connection conexion(String usuario, String constrasena,
                                      String host, int puerto, String sid)
    {
        try
        {
            //Iniciamos la conexión en la base de datos.
            return DriverManager.getConnection("jdbc:oracle:thin:" + usuario + "/" + constrasena + "@" + host + ":" + puerto + ":" + sid);
        }
        catch(Exception e)
        {
            System.err.println("Error iniciado la conexión a la base de datos: " + e.getMessage());
            return null;
        }
    }


    /**
     * Método principal en el que se ejecutan todas las consultas SQL.
     */
    public static void main(String args[])
    {
        //Cargamos los driver para trabajar con la base de datos Oracle
        cargarDriver();
      
        Connection conexion = null; //Objeto para la conexión a la BD
        Statement sentencia = null; //Objeto para la ejecutar una sentencia SQL
        PreparedStatement sentenciaP = null; //Objeto para crear sentencias parametrizables y reusables
        ResultSet resultado = null;//Objeto para guardar los resultados de las sentencis

        try
        {
            //Iniciamos la conexión en la base de datos
            conexion = conexion(USUARIO, CONTRASENA, HOST, PUERTO, SID);


            //***********  EJEMPLO DE CONSULTA SQL SENCILLA ************************//
           System.out.println("SELECT ename, job, sal\n" +
                               "FROM emp\n" +
                               "ORDER BY ename;\n");

            //Obtenemos una instancia de Statement con la que enviaremos instrucciones SQL a la base de datos.
            sentencia = conexion.createStatement();

            //creamos y ejecutamos una consulta SQL
            resultado = sentencia.executeQuery("SELECT ename, job, sal " +
                                               "FROM emp " +
                                               "ORDER BY ename");

            //Mostramos los resultados de la consulta
            System.out.println("Nombre  \tTrabajo  \tSueldo");
            while(resultado.next())
            {
                System.out.println(resultado.getString("ename") + "   \t" +
                                   resultado.getString("job") + "  \t" +
                                   resultado.getInt("sal"));
            }
            //*********************************************************************//



          
            //************ EJEMPLO DE CONSULTA SQL PREPARADA **********************//
            System.out.println("------------------------------------------------\n\n" +
                               "SELECT ename, sal\n" +
                               "FROM emp\n" +
                               "WHERE sal > ? AND job = ?;\n");

            //Creamos una sentencia de tipo PreparedStatement con la consulta SQL que queremos realizar
            sentenciaP = conexion.prepareStatement("SELECT ename, sal " +
                                                   "FROM emp " +
                                                   "WHERE sal > ? AND job = ?");
          
            //Asignamos los valores de los parámetros
            System.out.println("Usando: sal > 1000 y job = CLERK");
            sentenciaP.setInt(1, 1000); //El parámetro 1 es un entero con valor 1000
            sentenciaP.setString(2, "CLERK"); //El parámetro 2 es una cadena con el valor "CLERK"
          
            resultado = sentenciaP.executeQuery();

            //Mostramos los resultados de la consulta
            System.out.println("\nNombre   \tSueldo");
            while(resultado.next())
            {
                System.out.println(resultado.getString("ename") + "   \t" +
                                   resultado.getString("sal"));
            }

            //----- Reutilizamos la misma consulta con otros valores de los parámetros --------//

            //Asignamos los nuevos valores de los parámetros
            System.out.println("\nUsando: sal > 1300 y job = SALESMAN");
            sentenciaP.setInt(1, 1300);          //Aun que en este caso se han modificado
            sentenciaP.setString(2, "SALESMAN"); //los 2 parámetros puede modificarse uno solo

            //Ejecutamos la consutla con los nuevos valores de los parámetros
            resultado = sentenciaP.executeQuery();

            //Mostramos los resultados de la consulta
            System.out.println("\nNombre   \tSueldo");
            while(resultado.next())
            {
                System.out.println(resultado.getString("ename") + "   \t" +
                                   resultado.getString("sal"));
            }

            //*********************************************************************//




            //***********  EJEMPLO DE CREACION DE UNA TABLA  **********************//
            System.out.println("------------------------------------------------\n\n" +
                               "CREATE TABLE personas (\n" +
                               "dni VARCHAR(9) NOT NULL,\n" +
                      "nombre VARCHAR(10) NOT NULL,\n" +
                      "fecha_nacimiento DATE NOT NULL,\n" +
                      "sueldo INT DEFAULT 0,\n" +
                      "CONSTRAINT clave_p_persona PRIMARY KEY (dni));\n");

            //Obtenemos una instancia de Statement con la que enviaremos instrucciones SQL a la base de datos.
            sentencia = conexion.createStatement();

            //Creamos la nueva tabla
            sentencia.executeUpdate("CREATE TABLE personas ( " +
                                    "dni VARCHAR(9) NOT NULL, " +
                                    "nombre VARCHAR(10) NOT NULL, " +
                                    "fecha_nacimiento DATE NOT NULL, " +
                                    "sueldo INT DEFAULT 0, " +
                                    "CONSTRAINT clave_p_persona PRIMARY KEY (dni))");

            System.out.println("Tabla personas creada correctamente");
            //*********************************************************************//




            //***********  EJEMPLO DE INSERCION DE DATOS  **********************//
            System.out.println("------------------------------------------------\n\n" +
                               "INSERT INTO personas (dni, nombre, fecha_nacimiento, sueldo)\n" +
                               "VALUES('12345678A', 'Jose', TO_DATE('17/01/1989','dd/mm/yyyy'), 1200);\n");

            //Obtenemos una instancia de Statement con la que enviaremos instrucciones SQL a la base de datos.
            sentencia = conexion.createStatement();

            //Insertamos los datos en la tabla
            int filasInsertadas = sentencia.executeUpdate("INSERT INTO personas (dni, nombre, fecha_nacimiento, sueldo) " +
                                                          "VALUES('12345678A', 'Jose', TO_DATE('17/01/1989','dd/mm/yyyy'), 1200)");        

            if(filasInsertadas == 1)
                System.out.println("Se han insertado " + filasInsertadas + " fila.");
            else
                throw new SQLException("Error insertando datos en la tabla personas.");
            //*********************************************************************//




            //***********  EJEMPLO DE CONSULTA SQL SENCILLA ************************//
            System.out.println("------------------------------------------------\n\n" +
                               "SELECT dni, nombre, fecha_nacimiento, sueldo\n" +
                               "FROM personas;\n");

            //Obtenemos una instancia de Statement con la que enviaremos instrucciones SQL a la base de datos.
            sentencia = conexion.createStatement();

            //creamos y ejecutamos una consulta SQL
            resultado = sentencia.executeQuery("SELECT dni, nombre, fecha_nacimiento, sueldo " +
                                               "FROM personas");

            //Mostramos los resultados de la consulta
            System.out.println("DNI  \tNombre  \tFecha nacimiento  \tSueldo");
            while(resultado.next())
            {
                System.out.println(resultado.getString("dni") + "    " +
                                   resultado.getString("nombre") + "    \t" +
                                   resultado.getDate("fecha_nacimiento") + "\t\t" +
                                   resultado.getInt("sueldo"));
            }
            //*********************************************************************//



          
            //***********  EJEMPLO DE ELIMINACION DE TABLAS  **********************//
            System.out.println("------------------------------------------------\n\n" +
                               "DROP TABLE personas;");

            //Obtenemos una instancia de Statement con la que enviaremos instrucciones SQL a la base de datos.
            sentencia = conexion.createStatement();

            //Eliminamos la tabla
            sentencia.executeUpdate("DROP TABLE personas");
            System.out.println("Tabla personas eliminada correctamente");
            //*********************************************************************//




            //******  EJEMPLO DE VARIAS CONSULTAS EN LA MISMA TRANSACCION  ********//
            System.out.println("------------------------------------------------\n\n"
                             + "INSERT INTO dept (deptno, dname, loc)\n"
                             + "VALUES (50, 'Cálculo', 'A Coruña');\n\n"
                             + "INSERT INTO emp\nVALUES (6655, 'Juan', 'PRESIDENT', NULL, "
                             + "to_date('17/01/89','dd/mm/yy'), 5000,  NULL, 50)\n");

            boolean transaccionConfirmada = false;
            try
            {
                //Desactivamos el modo autocommit
                conexion.setAutoCommit(false);

                //Obtenemos una instancia de Statement con la que enviaremos instrucciones SQL a la base de datos.
                sentencia = conexion.createStatement();

                //Añadimos un nuevo departamento a la tabla dept
                sentencia.executeUpdate("INSERT INTO dept (deptno, dname, loc) " +
                                       "VALUES (50, 'Cálculo', 'A Coruña')");

                sentencia = conexion.createStatement();
                //Añadimos un trabajador al nuevo departamento
                sentencia.executeUpdate("INSERT INTO emp (ename, job, sal) " +
                                       " VALUES ('Juan'" +
                                       ",'PRESIDENT',6655)");
//, NULL, "
  //                                    + "to_date('17/01/89','dd/mm/yy'), "
    //                                  + "5000,  NULL, 50)");

                //Confirmamos la transacción
                conexion.commit();
                transaccionConfirmada = true;

                System.out.println("Departamento y empleado añadidos correctamente");

                //Reestablecemso el modo autocommit
                conexion.setAutoCommit(true);
            }
            finally
            {
                //si ha ocurrido algun problema deshacimos los cambios
                if (!transaccionConfirmada)
                {
                    conexion.rollback();
                    System.out.println("Ha ocurrido un problema.");
                }
            }
            //*********************************************************************//

          
          
          
            //****** ELIMINAMOS LO AÑADIDO EN LA TRANSACCION ANTERIOR ************//
            System.out.println("------------------------------------------------\n\n" +
                               "DELETE FROM emp WHERE empno = 6655;\n"
                             + "DELETE FROM dept WHERE deptno = 50;\n");

            //Obtenemos una instancia de Statement con la que enviaremos instrucciones SQL a la base de datos.
            sentencia = conexion.createStatement();

            //Eliminamos el empleado a la tabla emp
      //      sentencia.executeUpdate("DELETE FROM emp WHERE empno = 6655");

            //Obtenemos una instancia de Statement con la que enviaremos instrucciones SQL a la base de datos.
            sentencia = conexion.createStatement();

            //Elimanos el departamento de la tabla dept
            sentencia.executeUpdate("DELETE FROM dept WHERE deptno = 50");

            System.out.println("Departamento y empleado eliminados correctamente");
            //*********************************************************************//
        }
        catch (Exception e)
        {
            System.err.println("Se produjo el siguiente error: " + e.getMessage());
        }
        finally
        {
            try
            {
                //Cerramos la conexión establecida con la base de datos
                if(conexion != null)
                {
                    conexion.close();
                }

                if (resultado != null)
                {
                    resultado.close();
                }

                if (sentencia != null)
                {
                    sentencia.close();
                }

                if (sentenciaP != null)
                {
                    sentenciaP.close();
                }
            }
            catch(SQLException e)
            {
                System.err.println("Error cerrando la sesión en la base de datos: " + e.getMessage());
            }
        }
    }
}

Java una clase le archivos de directorios y busca palabras en archivos

import java.io.*;
import java.util.Calendar;

class LeeArchivo {
public static void main(String [] arg)
 {
File archivo = null;
try {
//archivo = new File("/home/heli/projava/2012012021-dbJal.log");//"archivo.txt" es el archivo que va a leer
String linea;
//String subcadena = "ORA-";
String [] words = {"ORA-","EXP-"};

       Calendar calendar = Calendar.getInstance();
       int anio_ = calendar.get(Calendar.YEAR);
       int mes_ = calendar.get(Calendar.MONTH)+1;
       int dia_ = calendar.get(Calendar.DAY_OF_MONTH);
System.out.print("año : " + anio_ + " mes: " + mes_ + " dia : " + dia_ + " \n");



//Muestra los archivos en el directorio mencionados
String sDirectorio = "/home/heli/projava/";
File f = new File(sDirectorio);

if (f.exists())
{ // Directorio existe
//System.out.println ("El directorio Existe");
}
else { //Directorio no existe
System.out.println ("El directorio NO existe");
return;
}

File[] ficheros = f.listFiles();
String nombreArchivo ="";
for (int x=0;x<ficheros.length;x++){
nombreArchivo=ficheros[x].getName();
if (nombreArchivo.indexOf("201201")>=0 ) {

System.out.println(" Leyendo archivo : " + nombreArchivo + " \n ");
//Busca palabra coincidente dentro de una linea
FileReader fr = new FileReader (nombreArchivo);
BufferedReader br = new BufferedReader(fr);
//int i,j,aux=0;

while((linea=br.readLine())!=null) {
//busca hora de inicio
if( linea.indexOf("Inicio de Respaldo en Servidor") >= 0  ) {
System.out.print("\n largo : " + linea.length() + " \n");
linea =linea.replace("/"," ") ;

System.out.print(linea + "\n ");
                                                        System.out.print("fecha inicial:" + linea.substring(linea.length()-19, linea.length()) + "\n" );

}

if( linea.indexOf("Termino de Respaldo en Servidor") >= 0  ) {
System.out.print( " fecha final: " +  linea.substring(linea.length()-19, linea.length()) + "\n" );
}

if( (linea.indexOf(words[0]) >= 0) ||  (linea.indexOf(words[1]) >= 0) ) {
System.out.print(linea + "\n");
}
else
{
//System.out.print("NO");
}
}
fr.close();
}
}


  }
catch(IOException a){
System.out.println(a);
 }
 }
}

virtualizacion con kvm windows 7 vitualizacion con kvm instalacion de windows 7 virtual

espacio ocupada de instalcion de windows 7 , 8.47 gb

tiempo de instalacion completa 1 hora y 10 minutos

espacio ocupada de instalacion de windows xp 3.13 gb

tiempo de instalacion 40 minutos

Creacion de una maquina virtual nueva

CLONACION DE UN EQUIPO

nose

crea maquinas virtuales

adicionando volumen

addicionando nueva ruta de deposito de maquinas virtuales

no se ve

asignando storage

finalizando asignacion de puente de red

asignando puente de red

asignando nueva red

inicio de creacion de maquina virtual

Detalle de host de maquinas virtuales

capturando contraseña del usuario

seleccionando modo pausa

antes de clonar para no apagar la maquina lo puse en modo pausa

asignando ruta donde estara el archivo imagen de la maquina virtual

cambio de ruta de la imagen clone