Click here to view the embedded video.

Click here to view the embedded video.

Puedes descargarlo en XDA-Developers

<form action=”Recoger.html” method=”get” name=”f1″ id=”f1″>
  Nombre Cliente:
  <input id=”campo_1″ value=”" type=”text” />
  <input id=”campo_2″ value=”" type=”text” />
  <input name=”Submit” type=”submit” />
</form>

Este es el código que lleva la página que recibe las variables.
Accedemos a la cadena que nos hemos enviado desde la otra página.
La función separa las variables que hemos recibido,
Unescape codifica las cadenas de caracteres que hemos recibido en formato URL. unescape(”%23″);

// devuelve #
    

<script>
function separateQueryString(){
queryString=location.search.substr(1);
pares=queryString.split(’&’);
$_GET=[];
for(ii in pares){
tmp=pares[ii].split(’=');
$_GET[tmp[0]]=unescape(tmp[1].split(’+').join(’ ‘));
}
//for (ii in $_GET){
// Si quieres mostrar todas las variables en un Div.
//document.getElementById(’nombre_Div’).innerHTML+=$_GET[ii]+’<br />’;
//}
document.getElementById(’text_1′).value=$_GET['campo_1'];
document.getElementById(’text_2′).value=$_GET['campo_2'];
}
window.onload=separateQueryString;
</script>

La página que recoge los valores, tiene que tener los campos con los ‘id’ que hemos enviado.

<div id=”nombre_Div”> <div/>
<input id=”text_1″ type=”text”>
<input id=”text_2″ type=”hidden”>

Layar, a través de la cámara y el geoposicionamiento, y seleccionando un motor de búsqueda entre los incluidos en la aplicación, podemos conocer datos acerca del monumento que estemos mirando, o buscar bares que pongan partidos de la liga por el Canal +, por ejemplo. Incluso tiene acceso a Google Maps, por si queremos saber cómo se llega a ese local.

Click here to view the embedded video.

Lo malo es la increible cantidad de batería que consume, pues hay que tener a la vez la cámara, el GPS, y estar conectados a internet, ya sea via Wi-Fi o 3G.

Ahora para saber dónde hay un Banco Santander ya no hay que preguntar a la gente, le preguntaremos al móvil.

fuente: and.roid.es

En Java, a la hora de crear documentos PDF, existen múltiples librerias que nos ayudan a generarlos, en este articulo vamos a hablar sobre la librería ITEXT.

ITEXT a parte de ser una buena librería para generar PDFs tiene la ventaja de que se integra facilmente con SPRING a la hora de desarrollar aplicaciones Web.

Los datos pueden ser escritos a un fichero o, por ejemplo, desde un servlet a un navegador web.

CARACTERÍSTICAS PRINCIPALES:

- Generación de documentos PDF (parrafos, tablas, imágenes, encabezados y pies de pagina…)

- Generar documentos dinámicos a partir de archivos XML o bases de datos

- Agregar marcadores de libros, números de página, marcas de agua, etc

- Split, concatenar, y manipular las páginas PDF

- Automatizar el llenado de formularios PDF

- Agregar firma digital a un archivo PDF

INSTALACIÓN:

Para empezar veamos donde descargarnos la librería

Esta es la web de la librería, aquí se puede ver la API, ejemplos y tutoriales:

http://itextpdf.com/

Una vez que seleccionamos descargrnos la version para Java nos redirecciona a esta otra página:

http://sourceforge.net/projects/itext/files/

Actualmente la versión más reciente es la 5.0.2

Una vez nos hemos descargado la librería, la añadimos al CLASSPATH de nuestro proyecto Java para poder utilizarla

EJEMPLO:

Este ejemplo abarca la creación de un documento PDF simple, para ver ejemplos mas complejos nos podemos descargar de la propia página muchos ejemplos que abarcan toda la funcionalidad de esta libreria:

http://www.itextpdf.com/examples/index.php

CÓDIGO:

import java.io.FileOutputStream;
import com.itextpdf.text.BaseColor;
import com.itextpdf.text.Chunk;
import com.itextpdf.text.Document;
import com.itextpdf.text.Element;
import com.itextpdf.text.Font;
import com.itextpdf.text.FontFactory;
import com.itextpdf.text.Image;
import com.itextpdf.text.PageSize;
import com.itextpdf.text.Paragraph;
import com.itextpdf.text.Phrase;
import com.itextpdf.text.Rectangle;
import com.itextpdf.text.Font.FontFamily;
import com.itextpdf.text.pdf.ColumnText;
import com.itextpdf.text.pdf.PdfPCell;
import com.itextpdf.text.pdf.PdfPTable;
import com.itextpdf.text.pdf.PdfPageEventHelper;
import com.itextpdf.text.pdf.PdfWriter;

public class Test {
 
 //Nombre del fichero PDF Resultante de la ejecucion
 public static final String RESULT = “Ejemplo1.pdf”;
 //Titulos
 public static final String CHUNK = “CHUNK”;
 public static final String PHRASE = “PHRASE”;
 public static final String PARAGRAPH = “PARAGRAPH”;
 public static final String TABLE = “TABLE”;
 public static final String IMAGE = “IMAGE”;
 //Textos
 public static final String SEPARADOR = “———————————————————————————————————————-”;
 public static final String CHUNK1 = “This is the smallest significant part of text that can be added to a document.”;
 public static final String CHUNK2 = “Most elements can be divided in one or more Chunks. A chunk is a String with a certain Font. All other layout parameters should be defined in the object to which this chunk of text is added.”;
 public static final String PHRASE1 = “A Phrase is a series of Chunks.”;
 public static final String CHUNKPHRASE21 = “A Phrase has a main Font,”;
 public static final String CHUNKPHRASE22 = ” but some chunks within the phrase can have a Font that differs from the main Font.”;
 public static final String CHUNKPHRASE23 = ” All the Chunks in a Phrase  have the same leading.”;
 public static final String PARAGRAPH1 = “A Paragraph is a series of Chunks and/or Phrases.”;
 public static final String PARAGRAPH2 = “A Paragraph has the same qualities of a Phrase, but also some additional layout-parameters: The indentation AND The alignment of the text”;

    public static void main (String[] args) {
     try
     {
      //Creacion del documento con un tamaño y unos margenes predeterminados
      Document document = new Document(PageSize.A4, 50, 50, 50, 50);
      //Al documento se le puede añadir cierta metaInformacion
      document.addAuthor(”FJHO”);
      document.addTitle(”EJEMPLO1″);

      //A DocWriter class for PDF.
      //When this PdfWriter is added to a certain PdfDocument,
      //the PDF representation of every Element added to this Document will be written to the outputstream.
      PdfWriter writer = PdfWriter.getInstance(document, new FileOutputStream(RESULT));
         //LEADING = separacion entre lineas del documento
         writer.setInitialLeading(16);
         Rectangle rct = new Rectangle(36, 54, 559, 788);
         //Definimos un nombre y un tamaño para el PageBox los nombres posibles son: “crop”, “trim”, “art” and “bleed”.
         writer.setBoxSize(”art”, rct);
        
         //Se crea una instancia de la clase que pinta la cabecera y el pie de pagina y se le asignan los eventos que ocurran en el PDF
         //La en la clase HeaderFooter se capturarar el evento onEndPage para pintarlos
            HeaderFooter event = new HeaderFooter();
            writer.setPageEvent(event);
           
         //Opens the document.
            //You have to open the document before you can begin to add content to the body of the document.
         document.open();
         //Ejemplos de CHUNKS
          //Creamos el CHUNK definiendo su tipo de letra, tamaño…
          Chunk titulo = new Chunk(CHUNK, FontFactory.getFont(FontFactory.COURIER, 20, Font.UNDERLINE, BaseColor.BLACK));
          //Lo añadimos al documento
          document.add(titulo);
          //CHUNK predefinido, es un salto de linea
          document.add(Chunk.NEWLINE);
          Chunk chunkSeparador =  new Chunk(SEPARADOR);
          Chunk chunkNormal = new Chunk(CHUNK1);
          document.add(chunkNormal);
          document.add(Chunk.NEWLINE);
          document.add(Chunk.NEWLINE);
          Chunk chunkTunning = new Chunk(CHUNK2,FontFactory.getFont(FontFactory.COURIER, 20, Font.ITALIC, BaseColor.GREEN));
          document.add(chunkTunning);
          document.add(Chunk.NEWLINE);
          document.add(Chunk.NEWLINE);
          Chunk chunkTunning2 = new Chunk(CHUNK2,new Font(FontFamily.HELVETICA, 6, Font.BOLD, BaseColor.WHITE));
          chunkTunning2.setBackground(BaseColor.BLACK, 10f, 10f, 10f, 10f);
          document.add(chunkTunning2);
          document.add(Chunk.NEWLINE);
          document.add(Chunk.NEWLINE);
          document.add(Chunk.NEWLINE);
          document.add(chunkSeparador);         
         //FIN Ejemplos de CHUNKS      
         //**************************************************************
         //Ejemplos de PHRASES
          titulo = new Chunk(PHRASE, FontFactory.getFont(FontFactory.COURIER, 20, Font.UNDERLINE, BaseColor.BLACK));
          document.add(titulo);
          document.add(Chunk.NEWLINE);
          Phrase phraseNormal = new Phrase(PHRASE1);
          document.add(phraseNormal);
          document.add(Chunk.NEWLINE);
          document.add(Chunk.NEWLINE);
          Phrase phraseTunning = new Phrase(new Chunk(CHUNKPHRASE21));
          phraseTunning.add(new Chunk(CHUNKPHRASE22, FontFactory.getFont(FontFactory.COURIER, 5, Font.ITALIC, BaseColor.GREEN)));
          phraseTunning.add(new Chunk(CHUNKPHRASE23, FontFactory.getFont(FontFactory.TIMES_ROMAN, 15, Font.BOLD, BaseColor.ORANGE)));
          document.add(phraseTunning);
          document.add(Chunk.NEWLINE);
          document.add(Chunk.NEWLINE);
          Phrase phraseConLeading = new Phrase(30, “Todo es la misma frase LEADING de esta PHRASE=100, Todo es la misma frase LEADING de esta PHRASE=100, Todo es la misma frase LEADING de esta PHRASE=100″);
          document.add(phraseConLeading);
          document.add(Chunk.NEWLINE);
          document.add(chunkSeparador);         
         //FIN Ejemplos de PHRASES
         //**************************************************************
         //Ejemplos de PARAGRAPH
          titulo = new Chunk(PARAGRAPH, FontFactory.getFont(FontFactory.COURIER, 20, Font.UNDERLINE, BaseColor.BLACK));
          document.add(titulo);
          document.add(Chunk.NEWLINE);
          // Añadir parrafo sin formato
          document.add(new Paragraph(PARAGRAPH1));
          Paragraph par = new Paragraph(PARAGRAPH2);
          par.setIndentationLeft(200);
          document.add(par);
          par = new Paragraph(PARAGRAPH2);
          par.setIndentationRight(300);
          document.add(par);
          // Añadir parrafo en Negrita           
          par = new Paragraph(PARAGRAPH2);
             par.getFont().setStyle(Font.BOLD);
             par.setAlignment(Element.ALIGN_CENTER);
             document.add(par);
          // Añadir parrafo en Cursiva
             par = new Paragraph(PARAGRAPH2);
             par.getFont().setStyle(Font.ITALIC);
             par.setAlignment(Element.ALIGN_RIGHT);
             document.add(par);
             // Añadir parrafo tunning
             par = new Paragraph(PARAGRAPH2,
         FontFactory.getFont(”arial”,   // fuente
              16,                    // tamaño
              Font.ITALIC,           // estilo
              BaseColor.RED));       // color
             document.add(par);
             par.setAlignment(Element.ALIGN_LEFT);
             document.add(chunkSeparador); 
             document.add(Chunk.NEWLINE);
             document.add(Chunk.NEWLINE);
         //FIN Ejemplos de PARAGRAPH
         //**************************************************************            
         //Ejemplos de TABLE
             titulo = new Chunk(TABLE, FontFactory.getFont(FontFactory.COURIER, 20, Font.UNDERLINE, BaseColor.BLACK));
          document.add(titulo);
             //Añadir tabla 5 columnas
             PdfPTable table = new PdfPTable(5);
            //Añadir CABECERA
             PdfPCell cell = new PdfPCell(new Phrase(”CABECERA”));
             cell.setColspan(5);
             cell.setBackgroundColor(BaseColor.GREEN);
             table.addCell(cell);
             //Añadir dos filas de celdas sin formato
             table.addCell(”1.1″);
             table.addCell(”1.2″);
             table.addCell(”1.3″);
             table.addCell(”1.4″);
             table.addCell(”1.5″);
             table.addCell(”2.1″);
             table.addCell(”2.2″);
             table.addCell(”2.3″);
             table.addCell(”2.4″);
             table.addCell(”2.5″);
             //tunning de Celdas
             cell = new PdfPCell(new Phrase(”Alto 3 celdas”));
             cell.setRowspan(2);
             cell.setVerticalAlignment(Element.ALIGN_MIDDLE);
             table.addCell(cell);
             table.addCell(”3.1″);
             table.addCell(”3.2″);
             table.addCell(”3.3″);
             table.addCell(”3.4″);
             table.addCell(”4.1″);
             table.addCell(”4.2″);
             table.addCell(”4.3″);
             table.addCell(”4.4″);
             table.addCell(”5.1″);
             cell = new PdfPCell(new Phrase(”Ancho 4 celdas”));
             cell.setHorizontalAlignment(Element.ALIGN_CENTER);
             cell.setColspan(4);
             table.addCell(cell);
             document.add(table);
             document.add(chunkSeparador);
         //FIN Ejemplos de TABLE
      //**************************************************************   
         //Ejemplos de IMAGE
             titulo = new Chunk(IMAGE, FontFactory.getFont(FontFactory.COURIER, 20, Font.UNDERLINE, BaseColor.BLACK));
          document.add(titulo);
       Image foto = Image.getInstance(”resources/ferrari.jpg”);
       foto.scaleToFit(100, 100);
       foto.setAlignment(Chunk.ALIGN_MIDDLE);
       document.add(foto);
      //FIN Ejemplos de IMAGE      
      //**************************************************************
      // Cierre del documento
         document.close();
     } catch (Exception ex) {
         System.out.println(ex.getMessage());
     }
    }
   
    static class HeaderFooter extends PdfPageEventHelper {

        public void onEndPage (PdfWriter writer, Document document) {
            Rectangle rect = writer.getBoxSize(”art”);
            //CABECERA
            ColumnText.showTextAligned(writer.getDirectContent(),
                    Element.ALIGN_RIGHT, new Phrase(”LaMandarinaMecanica”),
                    rect.getRight(), rect.getTop(), 0);
            //PIE
            ColumnText.showTextAligned(writer.getDirectContent(),
                    Element.ALIGN_CENTER, new Phrase(String.format(”page %d”, writer.getPageNumber())),
                    (rect.getLeft() + rect.getRight()) / 2, rect.getBottom() - 18, 0);
        }
    }
} 

 WEB:

Si lo que necesitamos es generar documentos PDF dinamicamente que se le abran al usuario directamente al interactuar con una página web (pinchar botones, links…), podemos crear un servlet que reciba las peticiones de creacion de ficheros PDF

CÓDIGO:

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.OutputStream;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import com.itextpdf.text.Document;
import com.itextpdf.text.DocumentException;
import com.itextpdf.text.Paragraph;
import com.itextpdf.text.pdf.PdfWriter;

public class Demo extends HttpServlet {

 public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
  doPost(request, response);
 }
 
 public void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException{
  
  /*GENERACION AL VUELO DE PDF*/
  try {
            // Texto que va a ser añadido al PDF
            String text = “Generacion al Vuelo de un PDF”;
           
            // Paso 1: Creamos el documento
            Document document = new Document();
            // Paso 2: Creamos un ByteArrayOutputStream
            // todo lo que se escriba en el documento
            // se escribe tambien en el ByteArrayOutputStream
            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            PdfWriter.getInstance(document, baos);
            // Abrimos el documento
            document.open();
            // Escribimos
            document.add(new Paragraph(text));
            // Cerramos
            document.close();
           
            // Hay que configurar las cabeceras para que
            //el navegador detecte que es un PDF
            response.setHeader(”Expires”, “0″);
            response.setHeader(”Cache-Control”,
                “must-revalidate, post-check=0, pre-check=0″);
            response.setHeader(”Pragma”, “public”);
            // Configuramos el content type
            response.setContentType(”application/pdf”);
            // Tamaño
            response.setContentLength(baos.size());
            // Esccribir el ByteArrayOutputStream a el ServletOutputStream
            OutputStream os = response.getOutputStream();
            baos.writeTo(os);
            os.flush();
            os.close();
        }
        catch(com.itextpdf.text.DocumentException e) {
            throw new IOException(e.getMessage());
        }
    }
}

Conectando con Oracle por JDBC (THIN y OCI).
Tenemos dos tipos de conexión JDBC, Thin y OCI ,
Para utilizar Thin necesitamos saber el host, el puerto, y el SID de la BBDD.

public void classcon3(){           
  try { 
          Class.forName(”oracle.jdbc.driver.OracleDriver”);
  } catch (ClassNotFoundException ex) {            
        ex.printStackTrace();                
  }
}             
public void classcadena3(){                      
  try{
    String urll;
    urll = “jdbc:oracle:thin:@nombre_host:1521:SID_10G”;
Connection conexion=DriverManager.getConnection(urll,”user90″,”pass90″);
Statement stmt = conexion.createStatement();              
ResultSet rset = stmt.executeQuery(”select * from errores”);

while(rset.next()){                
System.out.println(rset.getString(2) );
}
} catch(SQLException s){                         
s.printStackTrace();  
} }

Para utilizar OCI tenemos que tener instalado Oracle 10g client, usaremos el 10g driver para hacer la conexión. Con OCI solo necesitaremos saber el nombre de la BBDD para conectar.

public void classcon2(){           
 try {                                     
   Class.forName(”oracle.jdbc.driver.OracleDriver”);       
   } catch (ClassNotFoundException ex) {            
   ex.printStackTrace();                
   }  }             
public void classcadena2(){                      
 try{
   String urll;
   urll = “jdbc:oracle:oci:@nombre_host:”;
   Connection conexion = DriverManager.getConnection(”jdbc:oracle:oci:@(DESCRIPTION=(ADDRESS=(PROTOCOL=TCP)(HOST=nombre_host)(PORT=1521))(CONNECT_DATA=(SID=SID_10G)))”, “user90″, “pass90″);
  Statement stmt = conexion.createStatement();              
  ResultSet rset = stmt.executeQuery(”select * from errores”);

  while(rset.next()){                
  System.out.println(rset.getString(2) );
  }
  } catch(SQLException s){                         
  s.printStackTrace();  
 } }

Conectando con Oracle por ODBC.
Oracle, nos proporciona un ODBC driver que podemos usar para conectarnos desde una máquina Windows, necesitamos tener instalado un ODBC driver y configurarlo antes de conectar.

public void classcon(){  
 try {                 
     Class.forName(”sun.jdbc.odbc.JdbcOdbcDriver”);
  } catch (ClassNotFoundException ex) { 
     ex.printStackTrace();     
  }   }    
public void classcadena(){         
  try{  
    String urll;
    String pass;
    String nom;
   
urll = “jdbc:odbc:prueba”;       //:@nombre_host_ned10g:1521:SID_10G”; 
pass=”psword”; 
nom=”nombre”;
Connection conexion = DriverManager.getConnection(urll,nom,pass);        
Statement stmt = conexion.createStatement();   
ResultSet rset = stmt.executeQuery(”select * from errores”);

   while(rset.next()){ 
      System.out.println(rset.getString(2) );
   }      
} catch(SQLException s){      
    s.printStackTrace(); 
}   }

La aplicación en sí es una mezcla de realidad aumentada, video y datos en tiempo real. La aplicación permite, apuntando con la cámara a un recinto, reconocer el lugar y sugerir restaurantes, baños públicos, puntos de información, cafeterías, etc. De manera que con esta aplicación podremos tener acceso a todo eso, y lo que es más interesante en el caso del torneo, a las distintas pistas donde se estén jugando los partidos e información en tiempo real, como los jugadores y el resultado, pudiendo incluso ver videos de dicho partido por streaming. No puede faltar también conexión con Twitter para estar conectados con dicha red.

Click here to view the embedded video.

Esta aplicación es gratuita, y está disponible para los sistemas operativos iOS (iPhone) y Android.

Como vemos el diseño se acerca bastante a un HTC Hero, por ejemplo, y por fin dispondremos de una cámara delantera para videoconferencia. Ya se disponen de las características técnicas,entre las cuales cabe destacar:

- Pantalla Retina: La nueva pantalla del iPhone posee 4 veces más píxeles que los anteriores modelos (960×640) manteniendo las 3,5″ de tamaño de pantalla, con lo que a simple vista no se podrían distinguir dichos píxeles. El resultado es imágenes mucho más nítidas. Además la carcasa es oleófoba, o lo que es lo mismo, antigrasa, para evitar las manchas de huellas dactilares.

- Cámara: Ahora el iPhone tendrá cámara de 5 mpx en su parte trasera acompañada de un flash LED, y en su parte delantera tendrá una cámara con resolución VGA.

- Grabación de video en HD: Podremos grabar video con una calidad de 720p hasta 30 fps, y con la aplicación iMovie podremos editar dichos videos y montar nuestra propia película.

- Multitarea: Apple ha conseguido una multitarea muy efectiva, haciendo que sea posible cambiar de una aplicación a otra sin sufrir apenas ralentizaciones.

En cuanto al Bluetooth, las especificaciones indican Bluetooth 2.1 + EDR, lo que parece mejorar el rendimiento de conexión con dispositivos y utilizar 5 veces menos energía. Pero seguramente seguirá sin poder usarse para intercambio de archivos.

Precios y Fechas de salida:

- 199$ el iPhone 4 de 16 GB.
- 299$ el iPhone 4 de 32 GB.

El iPhone 4 estará disponible el 21 de Junio para Estados Unidos, Francia, Alemania, Reino Unido y Japón.

En Julio estará disponible en España, Australia, Belgica, Canadá, Dinamarca, Finlandia, Hong Kong, Irlanda, Italia, Luxemburgo, Holanda, Nueva Zelanda, Noruega, Singapur, Corea del sur, Suecia y Suiza.

Un índice es un conjunto de páginas asociado a una tabla (o a una vista) que se utiliza para acelerar la recuperación de filas de la tabla o para exigir unicidad.
Se utilizan índices para señalar la ubicación de una fila en una página de datos en lugar de tener que recorre todas las páginas de datos de una tabla.
Un índice contiene claves formadas a partir de una o más columnas de la tabla.

1.1 Acceso de SQL Server a los datos

Hay dos maneras de acceder a los datos:

Examinando todas las páginas de datos de una tabla, lo que se denomina recorrido de tabla.

1 Empieza por el principio de la tabla.
2 Avanza de página en página por todas las filas de la tabla.
3 Extrae las filas que cumplen los criterios de la consulta.

Utilizando índices. Cuando SQL Server utiliza un índice:

1 Recorre la estructura de árbol de índices para encontrar las filas solicitada por la consulta.
2 Extrae únicamente las filas necesarias que cumplen los criterios de la consulta.

1.2 Índices agrupados.

Un índice agrupado ordena y almacena las filas de datos de la tabla según la clave del índice agrupado. El índice agrupado se implementa como un árbol.
En un índice agrupado, los nodos raíz e intermedios contienen páginas de índice que incluyen filas de índice. Cada fila de índice contiene un valor de clave y un puntero a una página de nivel intermedio del árbol b o a una fila de datos en el nivel de hoja del índice.

Sólo puede haber un índice agrupado por tabla.

Los índices agrupados son más eficaces cuando se utilizan en consultas que hacen 1o siguiente:
Devuelven un intervalo de valores utilizando operadores como BETWEEN, >, > < y <=. Como los datos de la tabla se almacenan físicamente según el orden del índice, cuando se encuentra la fila con el primer valor utilizando el índice agrupado, se sabe con total seguridad que las filas con valores indizados subsiguientes están adyacentes físicamente.
Devuelven datos ordenados utilizando la cláusula ORDER BY o GROUP BY.
Un índice en las columnas especificadas en la cláusula ORDER BY o GROUP puede eliminar la necesidad de que el motor de base de datos ordene los dato~, puesto que las filas ya están ordenadas. Esto mejora el rendimiento de las consultas.
Devuelven datos combinados mediante cláusulas JOIN; normalmente son columnas de clave externa.
Devuelven conjuntos de resultados grandes.
Los índices agrupados no son adecuados cuando:
Los datos de las columnas indizadas cambian con frecuencia. Los cambios en un índice agrupado hacen que haya que mover toda la fila de datos porque el motor base de datos debe mantener los valores de datos de una fila ordenados físicamente.
Cuando crea una restricción PRIMARY KEY en una tabla o se utiliza UNIQUE , se crea automáticamente un índice único en una columna (o en varias columnas). De forma predeterminada, este índice es agrupado, lo que significa que la tabla ya no se almacenará como un montón. Puede forzar que sea no agrupado si utiliza la opción NONCLUSTERED de la instrucción CREATE TABLE.

1.3 Montón.
 
Un montón es una tabla sin un índice agrupado. Las filas de datos no se almacenan en ningún orden concreto y no hay ningún orden específico para la secuencia de las páginas de datos. Las páginas de datos no están vinculadas en una lista vinculada.
Utilizará un montón de forma predeterminada siempre que no defina un índice agrupado en una tabla.

1.4 Índice no agrupado.
 
Los índices no agrupados tienen la misma estructura de árbol b que los índices agrupados, excepto que las filas de datos de la tabla subyacente no se ordenan y se almacenan según sus claves no agrupadas. En el índice no agrupado, los datos y el índice se almacenan por separado, y el nivel de hoja del índice consta de páginas de índice en lugar de páginas de datos.
Los índices no agrupados están diseñados para mejorar el rendimiento de las consultas utilizadas con frecuencia que no están cubiertas por un índice agrupado. Si su tabla ya tiene un índice agrupado y necesita indizar otra columna, la única opción que tiene es utilizar un índice no agrupado.

Cree los índices agrupados antes que los no agrupados. SQL Server vuelve a generar automáticamente los índices no agrupados existentes cuando:
o Se quita un índice agrupado existente.
o Se crea un índice agrupado.
o Se modifican las columnas que definen el índice agrupado.
Evite el uso de muchos índices no agrupados cuando la tabla se utilice en una aplicación de procesamiento de transacciones en línea (OLTP) o cuando se actualice con frecuencia. La existencia de muchos índices en una tabla afecta el rendimiento de las instrucciones INSERT, UPDATE y DELETE, ya que hay que actualizar todos los índices a medida que cambian los datos de la tabla

 2. Índices únicos.

Un índice único es un índice que garantiza que todos los datos de una columna indizada son únicos y no contiene valores duplicados.
Cuando existe un índice único, el motor de base de datos comprueba si hay valores duplicados cada vez que se agregan datos utilizando una operación de inserción.

2.1 Consideraciones para crear índices con varias columnas.
 
El rendimiento de las consultas mejora si se utilizan índices compuestos. Sin embargo, las claves amplias aumentan los requisitos de almacenamiento de un índice.

La cláusula WHERE de una consulta debe hacer referencia a la primera columna del índice compuesto para que el optimizador de consultas utilice el índice compuesto

Todas las columnas de un índice compuesto deben proceder de la misma tabla, excepto cuando se crea un índice en una vista, en cuyo caso deben proceder todas de la misma vista.

2.2 Índices con particiones.
 
De forma similar a las tablas con particiones, los índices con particiones son índices agrupados o no agrupados en los que las páginas de índice se separan horizontalmente en varias ubicaciones físicas basándose en un intervalo de valores de la columna de índice. Las ubicaciones físicas para las particiones son los grupos de archivos.
Un índice cuyas particiones se han creado de la misma forma que su tabla se dice que está “alineado” con la tabla.

2.3 Opciones para incorporar espacio libre a los índices.

La opción FILLFACTOR le permite asignar un porcentaje (de 0 a 100) de espacio libre en las páginas de índice de nivel de hoja para reducir la división de páginas. Este porcentaje determina cuántas páginas de nivel de hoja se deben rellenar.

Utilizar un valor bajo de factor de relleno para los entornas de procesamiento de transacciones en línea (OLTP). Esto permite tener el máximo espacio para el crecimiento en aquellas tablas donde se insertan filas con frecuencia o donde se modifican valores de clave de índice con frecuencia.
Utilizar un valor alto de factor de relleno para los entornas de procesamiento analítico en línea (OLAP).

3.  Optimización de índices.

La efectividad de los índices desempeña un papel importante en el rendimiento global para la base de datos. Por tanto, es importante asegurarse de que los índices se diseñan e implementan desde el principio de la forma más adecuada para sus aplicaciones. Una vez implementados los índices, debe mantenerlos para garantizar su rendimiento óptimo continuado. A medida que se agregan, modifican y eliminan datos de la base de datos, los índices se van fragmentando.

3.1 Fragmentación de índices.
 
La fragmentación de índices es el uso ineficiente de páginas dentro de un índice. La fragmentación se produce con el tiempo, a medida que se modifican datos.
Hay dos tipos de fragmentación:
Interna: Uso ineficiente de páginas dentro de un índice porque la cantidad de datos almacenados dentro de cada página es menor de lo que la página de datos puede contener.
Externa: Uso ineficiente de las páginas dentro de un índice porque el orden lógico de las páginas es erróneo.
Si el índice está fragmentado más del 30 % se recomienda que se vuelva a generar el índice (REBUILD), sino se recomienda reorganizarlo (REORGANIZE).

TNS:el listener no ha encontrado ningún manejador disponible con una pila de protocolos coincidente

El otro día nos dió aquí al tratar de conectar a BBDD, y era porque estabamos cerca de alcanzar el número máximo de sesiones y procesos establecidos.

Si en máquina ejecutais cualquiera de estas dos líneas, os dará el número de conexiones que hay en ese momento:

ps -ef | grep oracleSID | grep -v grep | wc -l
ps aux | grep oracleSID | grep -v grep | wc -l

Teneís que poner oracle unido al SID de vuestra BBDD.

select NAME, DISPLAY_VALUE, DESCRIPTION from v$parameter where name in (’processes’,’sessions’);

Si es así, lo podéis aumentar de esta manera:

SQL> alter system set processes=300 scope=spfile;
SQL> alter system set sessions=300 scope=spfile;

Luego sólo queda tirar y levantar la BBDD (siempre que tengamos los permisos suficientes)

SQL> shutdown immediate;
SQL> startup;

Claro que si no tenéis permisos hacer esto, siempre podéis “eliminar” conexiones. Si no sabéis como, echarle un ojo a otro post que hay por ahí publicado sobre esto. 

# Forms applet archive setting for JInitiator
archive_jini=f90all_jinit.jar, archivo.jar
# Forms applet archive setting for Microsoft Internet Explorer native JVM
archive_ie=f90all.cab, archivo.jar

Añadimos el Bean en la pantalla y ponemos la ruta y el nombre del bean.jar en las propiedades del Bean, en Clases de implementación añadimos:
oracle/forms/archivo (sin la extensión).

El concepto consiste en una pantalla de este material extensible, que hace que no solo extendamos la superficie, también podremos ajustar el ratio, de manera que si queremos ver una película en formato 16:9, solo tendremos que extenderla, y si queremos ver algo en proporción 4:3 la encogeremos.

También incluye un mini proyector que hará posible proyectar elementos del escritorio enfrente de la pantalla.

Fuente: Gizmodo

Click here to view the embedded video.

CLASE PPAL (testReflexion)

import tareas.Tarea1;
import tareas.Tarea2;
import tareas.Tarea3;
import tareas.Tarea4;
import tareas.Tarea5;

public class testReflexion {

 public static void main(String[] args)
 {
  String tarea1 = “Tarea1″;
  String tarea2 = “Tarea2″;
  String tarea3 = “Tarea3″;
  String tarea4 = “Tarea4″;
  String tarea5 = “Tarea5″;
  
  //En este caso el supuesto parametro de entrada seria–> “Tarea4″
  String param = tarea4;
  
  if (param.compareTo(tarea1)==0)
  {
   Tarea1 t = new Tarea1();
   t.ejecutarTarea();
  }
  else if (param.compareTo(tarea2)==0)
  {
   Tarea2 t = new Tarea2();
   t.ejecutarTarea();
  }
  else if (param.compareTo(tarea3)==0)
  {
   Tarea3 t = new Tarea3();
   t.ejecutarTarea();
  }
  else if (param.compareTo(tarea4)==0)
  {
   Tarea4 t = new Tarea4();
   t.ejecutarTarea();
  }
  else if (param.compareTo(tarea5)==0)
  {
   Tarea5 t = new Tarea5();
   t.ejecutarTarea();
  }
  //este else if sera tan grande como tareas diferentes se puedan ejecutar
 }

}

 CLASE TAREA (todas son iguales, sólo cambia el mensaje) 

package tareas;

public class Tarea4 {
 
 String mensaje = “”;
 
 public Tarea4()
 {
  this.setMensaje(”Se ha ejecutado la tarea 4″);
 }

 public void ejecutarTarea()
 {
  System.out.println(mensaje);
 }

 public String getMensaje() {
  return mensaje;
 }

 public void setMensaje(String mensaje) {
  this.mensaje = mensaje;
 }
 
}

 

 

 Java dispone de un mecanismo denominado reflexión por el cual a traves del nombre de una clase podemos obtener un objeto de dicha clase, crear una instancia de ella, obtener todas sus propiedades (publicas), obtener todos sus métodos (publicos)…

 Utilizando reflexión, si el parámetro que nos llega es el nombre de la clase, podemos obtener una instancia de la clase directamente, del mismo modo nos podrían pasar el método que queremos ejecutar, incluso los parámetros de entrada para ese método. Ejemplo2(usando Reflexion):

CLASE PPAL (testReflexion2)

import java.lang.reflect.*;

public class testReflexion2 {
 public static void main(String[] args)
 {
  String tarea1 = “Tarea1″;
  String tarea2 = “Tarea2″;
  String tarea3 = “Tarea3″;
  String tarea4 = “Tarea4″;
  String tarea5 = “Tarea5″;
  
  //En este caso el supuesto parametro de entrada seria–> “Tarea4″
  String param = tarea4;
  
  Class clase;
  Object objeto;
  Method ejecutarTarea;
  
  try
  {
   // Cargamos la clase a partir del nombre
   //la ruta tienen que ser completa
   clase = Class.forName(”tareas.”+tarea4);
   try
   {
    // creamos la instancia de la clase
    objeto = clase.newInstance();
    
    try
    {
     //obtenemos el metodo
     ejecutarTarea = clase.getMethod(”ejecutarTarea”, null);
     //ejecutamos el método
     ejecutarTarea.invoke(objeto, null);
    }
    catch (NoSuchMethodException e)
{
     System.out.println(”Error al acceder al metodo. ” + e);
            } catch (InvocationTargetException e)
{
                 System.out.println(”Error al ejecutar el metodo. ” + e);
           }
   }
   catch (IllegalAccessException e)
{
    System.out.println(”Error al instanciar el objeto. ” + e);   
   }
   catch (InstantiationException e)
{
            System.out.println(”No se ha encontrado la clase. ” + e);
       }
      }
  catch (ClassNotFoundException e)
{
   System.out.println(”Error al instanciar el objeto. ” + e);   
  }
 }
}

Podríamos delegar la creación de nuevos objetos a una clase factoria, de esta manera se hace transparente la creación de los objetos al programa principal.Ejemplo 3 (Usando Reflexión, Fatoria e Interface):

CLASE PPAL (testReflexion3)

import tareas.InterfaceTarea;
import factoria.Factoria;

public class testReflexion3 {
 public static void main(String[] args)
 {
  String tarea1 = “Tarea1F”;
  String tarea2 = “Tarea2F”;
  String tarea3 = “Tarea3F”;
  String tarea4 = “Tarea4F”;
  String tarea5 = “Tarea5F”;
  
  //En este caso el supuesto parametro de entrada seria–> “Tarea1F”
  String param = tarea1;
  Factoria f = new Factoria();
  InterfaceTarea it = f.getTarea(param);
  it.ejecutarTarea();
  
 }
}

CLASE FACTORIA

package factoria;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

import tareas.InterfaceTarea;

public class Factoria {

 public static InterfaceTarea getTarea( String tarea ) {
  InterfaceTarea objeto = null;
  Class clase = null;
  try
  {
   clase = Class.forName(”tareas.”+tarea);
   try
   {
    objeto = (InterfaceTarea)clase.newInstance();
   }
   catch (InstantiationException e) {
          System.out.println(”No se ha encontrado la clase. ” + e);
      }
   catch (IllegalAccessException e) {
    System.out.println(”Error al instanciar el objeto. ” + e);   
   }
  }
  catch (ClassNotFoundException e) {
   System.out.println(”Error al instanciar el objeto. ” + e);   
  }
  return objeto;
 }
}

CLASE INTERFACETAREA

package tareas;

public interface InterfaceTarea {
 void ejecutarTarea();
}

CLASE TAREA (adaptada a usar el interface)

package tareas;

public class Tarea1F implements InterfaceTarea{
 
 String mensaje = “”;
 
 public Tarea1F()
 {
  this.setMensaje(”Se ha ejecutado la tarea 1″);
 }

 public void ejecutarTarea()
 {
  System.out.println(mensaje);
 }

 public String getMensaje() {
  return mensaje;
 }

 public void setMensaje(String mensaje) {
  this.mensaje = mensaje;
 }
}

 

Principales métodos de la API Reflection de JAVA:

java.lang.Class forName(String className): Carga una clase del classpath a partir de su nombre (nombre completo, con todos los paquetes. Si la clase no se puede cargar, porque no se encuentra en el classpath, se lanzará una java.lang.ClassNotFoundException.

java.lang.reflect.Field getField(String name): Devuelve un campo público de la clase, a partir de su nombre. Si la clase no contiene ningún campo con ese nombre, se comprueban sus superclases recursivamente, y en caso de no encontrar finalmente el campo, se lanzará la excepcion java.lang.NoSuchFieldException.

java.lang.reflect.Field[] getFields(): Devuelve un array con todos los campos públicos de la clase, y de sus superclases.

java.lang.reflect.Method getMethod(String name, Class[] parameterTypes): Devuelve un método público de la clase, a partir de su nombre, y de un array con las clases de los parámetros del método. Si la clase no contiene ningún método con ese nombre y esos parámtetros, se lanzará la excepcion java.lang.NoSuchMethodException.

java.lang.reflect.Method[] getMethods(): Devuelve un array con todos los métodos públicos de la clase, y de sus superclases.

java.lang.Class[] getInterfaces(): Devuelve un array con todos los interfaces que implementa la clase.

public String getName(): Devuelve el nombre del campo.

public Class getType(): Devuelve la clase del campo.

public Object get(Object obj): Devuelve el valor del campo en un objeto.

public void set(Object obj, Object value): Asigna un valor al campo en un objeto.

public String getName(): Devuelve el nombre del método.

public Class[] getParameterTypes(): Devuelve un array con las clases de los parámetros del método.

public Class[] getExceptionTypes(): Devuelve un array con las clases de las excepciones que puede lanzar el método.

public Class getReturnType(): Devuelve la clase del valor que devuelve el método.

public Object invoke(Object obj, Object[] args): Ejecuta el método sobre un objeto, pasándole los parámetros necesarios, y devuelve su resultado.

Lo primero es descargar estos dos archivos:

Parte 1: www.megaupload.com/?d=9QRVPB8H
Parte 2: www.megaupload.com/?d=WO4ZESU6

Después copia el contenido de los dos archivos en la raíz de tu MS (si te pregunta sobreescribir, dile que sí), y ya estamos listos para usar el eloader. Para ejecutarlo tendremos que iniciar la demo de Patapon 2, y elegir continuar para cargar la partida salvada. Cuando salga una pantalla pidiendo que pulses cualquier botón, pulsa X. A continuación nos saldrá una pantalla de fondo azul, y pulsamos R. En este momento ya hemos cargado el EBOOT.PBP que está en la raíz de la Memory Stick (en este caso el emulador). Si quisiéramos usar otro homebrew, tendremos que copiar los archivos que contenga en la raíz de la tarjeta, y hacer el mismo método.

Para conseguir la última versión del eloader, descarga este archivo y copialo en la MS (sobreescribir).

Problemas que pueden surgir:

-Crash al cargar la aplicación, volved a intentarlo si eso pasa ya que muchas veces no sale al primer intento.

-Regreso al menú XMB. Si ocurre, volved a intentarlo.

-Problema mas común: el cambio radical entre los firmwares 5.XX y 6.XX, asi que a los usuarios con una firmware 6.XX posiblemente no os funcionen muchas aplicaciones. Si es así, no os preocupeis, tarde o temprano saldrá alguna solución.

Click here to view the embedded video.

¿Cúal es el navegador más rápido?. ¿Cúal se come más recursos?. ¿Cúal lee antes el DOM?. Rendimiento JavaScript, integración CSS…

Valoración global.

FUENTE  sixrevisions.com

OPERATIVA
Para trabajar con ficheros, es básico conocer la operativa de las dos operaciones más normalmente usadas.
ESCRITURA
1.     Declarar el descriptor
2.     Abrir el fichero con FOPEN de modo escritura
3.     Escribir los datos usando PUT, FPUT o PUT_LINE.
4.     Cerrar fichero FCLOSE

LECTURA
1.     Declarar el descriptor
2.     Declarar variable para almacenar datos
3.     Abrir el fichero con FOPEN de modo lectura.
4.     Leer datos con GET_LINE
5.     Cerrar fichero FCLOSE

FUNCIONES

1.    UTL_FILE.OPEN

· Se utiliza para abrir un fichero en modo determinado.
· Si es todo es correcto, devuelve un DESCRIPTOR diferente de NULL.
· Sintaxis:
Descriptor utl_file.file_type;
Descriptor := UTL_FILE.FOPEN (‘Path’,’Nombre_Fichero’,’modo’);

El Descriptor debe ser una variable de tipo UTL_FILE.FILE_TYPE previamente declarada.
PATH + Nombre Fichero. El Path debe existir.
· Modo.
      R: Lectura
      W: Lectura y escritura en modo reemplazar. Si el fichero existe lo borra, sino lo crea
      A: Lectura y escritura en modo añadir. Si el fichero no existe ? INVALID_OPERATION.

declare
descriptor utl_file.file_type;
fichero_cont varchar2(100);
begin
 descriptor := utl_file.fopen(’DIR_TEST’,'fichero_oracle.txt’,'w’);
 fichero_cont := ‘Creando el nuevo fichero ‘;
 utl_file.put_line(descriptor,fichero_cont);
 utl_file.fclose(descriptor);
end;
/

2. UTL_FILE.IS_OPEN

Devuelve TRUE si el descriptor de fichero está aún abierto.
Sintaxis:
auxiliar Boolean;
auxiliar := UTL_FILE.IS_OPEN(Descriptor);

3. UTL_FILE.GET_LINE

Lee una línea de DATOS del fichero especificado.
Se necesita una variable de salida (buffer_salida) lo suficientemente largo para almacenar todos los datos hasta el retorno de carro ( no incluido en buffer).
Sintaxis:

buffer_salida varchar2(2000); !! Tiene que ser mayor que cualquier línea de nuestro fichero.
UTL_FILE.GET_LINE(‘Descriptor’,buffer_salida); 

4. UTL_FILE.FCLOSE/FCLOSE_ALL

Se utiliza para el fichero abierto y asignado a ese descriptor.
Con FCLOSE_ALL se cierran todos los ficheros que estén en ese momento abiertos.
Si un programa acaba y existen ficheros abiertos, puede afectar al contenido de estos archivos.
Sintaxis:
UTL_FILE.FCLOSE(‘Descriptor’);
UTL_FILE.FCLOSE_ALL;

declare
descriptor utl_file.file_type;
salida varchar2(100);
fichero_cont varchar2(100);
auxiliar Boolean;
begin
       descriptor := utl_file.fopen(’DIR_TEST’,'fichero_oracle.txt’,'r’);
       utl_file.get_line(descriptor,salida);
       dbms_output.put_line(’ Contenido del fichero: ‘ || salida);
       auxiliar := UTL_FILE.IS_OPEN(descriptor);
       if auxiliar = TRUE then
         dbms_output.put_line(’ El fichero esta abierto ‘);
       else
         dbms_output.put_line(’ El fichero esta cerrado ‘);
       end if;
       UTL_FILE.FCLOSE(descriptor); /* Para cerrar el fichero */
end;
/

Devolverá:

 

Contenido del fichero: Añadiendo al nuevo fichero

El fichero esta abierto

 

NO SE PUEDE LEER Y ESCRIBIR EN EL MISMO FICHERO A LA VEZ.

5. UTL_FILE.PUT

Se utiliza para escribir datos en un fichero.
Los datos se añaden a continuación de donde están situados.
No se añade el “ fin de línea “. Lo escribe a continuación de la última línea.
Sintaxis:
UTL_FILE.PUT(‘Descriptor’,buffer);

6. UTL_FILE.NEW_LINE

Se utiliza para añadir 1 o más saltos de línea al fichero.
Si el número pasado el menos o igual a cero no ocurre nada.
Sintaxis:
UTL_FILE.NEW_LINE(‘Descriptor’,’Numero lineas’);

7. UTL_FILE.PUT_LINE

Se utiliza para escribir datos (caracteres, fechas, números en un fichero, añadiendo al final un salto de línea.
Los datos se añaden a continuación de donde están situados.
Sintaxis:
UTL_FILE.PUT_LINE(‘Descriptor’,buffer);

8. UTL_FILE.PUTF

Se utiliza para escribir datos en un fichero con un formato determinado.
Los operador utilizados son idénticos a los utilizados en el lenguaje C (%s, \n…);
Sintaxis:
UTL_FILE.PUTF (‘Descriptor, formato, arg1, arg2,…);

9. UTL_FILE.FFLUSH

Se utiliza para escribir físicamente todos los datos pendientes de escritura
Todas las operaciones de escritura se hacen a través de buffers intermedios para rapidez del sistema.
Sintaxis:
UTL_FILE.FFLUSH(‘Descriptor’);

declare
descriptor utl_file.file_type;
datos_put varchar2(100);
datos_put_line varchar2(100);
auxiliar Boolean;
begin
descriptor := utl_file.fopen(’DIR_TEST’,'fichero_oracle.txt’,'w’);
   loop
       datos_put := ‘Esto es con el put’;
       utl_file.put(descriptor,datos_put);   – Lo escribe todo seguido
       datos_put := ‘Continuacion del put’;
       utl_file.put(descriptor,datos_put);
       datos_put_line := ‘  Esto es put_line’;
       utl_file.put_line(descriptor,datos_put_line); 
       utl_file.new_line(descriptor,2);
       datos_put_line := ‘ Continuanos con el put_line’;
       utl_file.put_line(descriptor,datos_put_line);
    utl_file.fclose(descriptor);
    exit;
   end loop;
end;
/

FUNCIONES NUEVAS A PARTIR DE ORACLE 10g

- FCOPY. Copiar parte de un fichero a otro:

BEGIN
UTL_FILE.FCOPY (’C:\Ficheros’,'datos.txt’,
               ‘C:\Ficheros’,'copia_datos.txt’,1,5); — Es por línea, si quiero que copie todo elimino los parámetros. El fichero segundo no hace falta que exista y si existe lo reemplaza
end;
/

- FREMOVE. Borrar un fichero:

Si el último parámetro es TRUE y el fichero existe sobreescribe el fichero e ignora el error. Si existe y es FALSE da error. Si no existe no da error en ningún caso

BEGIN
 UTL_FILE.FREMOVE(’C:\Ficheros’,'prueba.txt’);
END;
/

- FRENAME. Renombrar un fichero:

BEGIN
  UTL_FILE.FRENAME(’C:\Ficheros’,'datos.txt’,'C:\Ficheros’,'nuevos_datos.txt’,false);
END;
/

- FGETPOS. Devuelve la posición en bytes donde nos encontramos:

DECLARE
v_datos varchar2(2000);
GET_POS NUMBER;
descriptor utl_file.file_type;
BEGIN
descriptor := utl_file.fopen(’c:\ficheros’,'datos.txt’,'r’);
  — No hemos hecho nada : devuelve 0
  GET_POS := UTL_FILE.FGETPOS (descriptor);
  dbms_output.put_line(get_pos);
 –Leemos una línea
 utl_file.get_line(descriptor,v_datos);
  GET_POS := UTL_FILE.FGETPOS (descriptor);
  dbms_output.put_line(get_pos);
utl_file.fclose(descriptor);
end;
/

- Función FSEEK. Sirve para posicionarnos en un byte determinado:

DECLARE
v_datos varchar2(2000);

descriptor utl_file.file_type;
BEGIN
descriptor := utl_file.fopen(’c:\ficheros’,'datos.txt’,'r’);

 –Nos posicionamos en el byte 16
 utl_file.fseek(descriptor,16);
 
 – Leemos la línea
 utl_file.get_line(descriptor,v_datos);

 dbms_output.put_line(v_datos);

utl_file.fclose(descriptor);
end;
/

Con la función GET_DDL de este paquete, extraeremos la DLL. Su sintaxis es la siguiente:

 

DBMS_METADATA.GET_DDL (
object_type IN VARCHAR2,
name IN VARCHAR2,
schema IN VARCHAR2 DEFAULT NULL,
version IN VARCHAR2 DEFAULT ‘COMPATIBLE’,
model IN VARCHAR2 DEFAULT ‘ORACLE’,
transform IN VARCHAR2 DEFAULT ‘DDL’)
RETURN CLOB; 

 

Los parámetros que utiliza son:

1 .Tipo de objeto (tabla, index, vista…)

2. Nombre del objeto

3. El esquema al que pertenece ( No es necesario)

4. Versión de servidor para la cual se extraerá el código. Establece un filtro que limita la extracción del metadata para objetos superiores la versión indicada, que nunca puede ser menos de la 9.2.0.

5. Model: Por ahora sólo ORACLE

6. Con este parámetro podemos indicar si el metadata lo devolverá en DDL o en XML

 

 

SELECT dbms_metadata.get_ddl(’TABLE’, ‘PRUEBA’, ‘ORACLE’) from dual;

Devolvería:

  CREATE TABLE “ORACLE”.”PRUEBA”

   (    “NOMBRE” VARCHAR2(1)

   ) PCTFREE 10 PCTUSED 40 INITRANS 1 MAXTRANS 255 NOCOMPRESS LOGGING

  STORAGE(INITIAL 65536 NEXT 1048576 MINEXTENTS 1 MAXEXTENTS 2147483645

  PCTINCREASE 0 FREELISTS 1 FREELIST GROUPS 1 BUFFER_POOL DEFAULT)

  TABLESPACE “ORACLE4″

 

 

 

Podemos extraer el esquema entero o unas tablas específicas:

spool tablas.lst 

SELECT DBMS_METADATA.GET_DDL(’TABLE’,u.table_name)
   FROM USER_TABLES u

 

WHERE table_name like ‘BP%’;

spool off 

 

 

 

 

 

 

Incluso podemos recuperar todo el esquema de la BBDD, con una sencilla sentencia:

SELECT DBMS_METADATA.GET_DDL (OBJECT_TYPE, OBJECT_NAME, USER)
FROM USER_OBJECTS

 Antes de realizar esto podemos cambiar algunos parámetros de metadata con el procecimiento SET_TRANSFORM_PARAM.

-       Para evitar que el output salga formateado con líneas en blanco y sangrías, en todos los objetos:

dbms_metadata.set_transform_param(dbms_metadata.session_transform, ‘PRETTY’, false);

-       Si queremos generar los atributos del segmento (storage attribute, tablespace…), storage y tablespace para las tablas y los índices de los objetos definidos. Por defecto son todos TRUE:

dbms_metadata.set_transform_param(dbms_metadata.session_transform, ‘SEGMENT_ATTRIBUTES’, true);
dbms_metadata.set_transform_param(dbms_metadata.session_transform, ‘STORAGE’, true);
dbms_metadata.set_transform_param(dbms_metadata.session_transform, ‘TABLESPACE’, true);

-       Si se quiere evitar que las constrains (non-referential y referential) se incluyan en las sentencias DDL de las tablas. Por defecto es true :

dbms_metadata.set_transform_param(dbms_metadata.session_transform, ‘CONSTRAINTS’, false);
dbms_metadata.set_transform_param(dbms_metadata.session_transform, ‘REF_CONSTRAINTS’, false);

dbms_metadata.set_transform_param(dbms_metadata.session_transform, ‘CONSTRAINTS_AS_ALTER’, false);

Para más información sobre estas opciones, aquí encontré una tabla que lo explica bastante bien.

http://www.myoracleguide.com/s/gen_schema.htm

Es una nueva funcionalidad, a partir de Oracle 10gR2, que nos permite ejecutar una sentencia DML completa y si en el transcurso de la ejecución, algún registro diera error, se insertará en una tabla de error para, posteriormente, poder corregirlo y volver a insertarlo, continuando con los siguientes registros.

Así no tendremos que ir controlando por registro o por bloque de registros si se ha producido un error para realizar el commit.

Lo primero de todo. Ver si lo tenemos instalado:

 SELECT OBJECT_NAME FROM ALL_OBJECTS

      WHERE OBJECT_NAME LIKE ‘%DBMS_%’

          AND OBJECT_TYPE = ‘PACKAGE’ ORDER BY 1;

Si creamos una tabla:

create table PRUEBA (nombre varchar2(1));

E intentamos insertar en ella niveles del 1 al 10, el último registro nos dará error.

Insert into prueba select level from dual CONNECT BY level <= 10;

Esta sentencia nos dará una especie de for del 1 al 10.

ERROR at line 1:

ORA-12899: value too large for column “MANTE90″.”PRUEBA”.”NOMBRE” (actual: 2,

maximum: 1).

Y como vemos no se habrá creado ningún registro en la tabla.

 SQL> select * from prueba;

 no rows selected.

Ahora crearemos la tabla de errores:

EXEC dbms_errlog.create_error_log(’PRUEBA’, ‘ERROR_PRUEBA’);

 Nombre                                                Nulo?    Tipo
—————————————————– ——– ————————————
ORA_ERR_NUMBER$                                           NUMBER
ORA_ERR_MESG$                                                VARCHAR2(2000)
ORA_ERR_ROWID$                                              ROWID
ORA_ERR_OPTYP$                                              VARCHAR2(2)
ORA_ERR_TAG$                                                   VARCHAR2(2000)
NOMBRE                                                                VARCHAR2(4000)

Cómo veis genera una columna por cada columna de la tabla a la que se asocia.

Bien, ahora vamos a insertar los registros otra vez.

INSERT INTO PRUEBA
SELECT level  FROM dual
CONNECT BY level <= 10
LOG ERRORS INTO ERROR_PRUEBA REJECT LIMIT UNLIMITED; 

Con esto insertaremos en la tabla PRUEBA 9 registros correctos y uno en la de error, ya que el tamaño superará lo establecido en la columna. 

No es necesario introducir INTO…, se insertarán en la tabla asignada por defecto cuando creamos la tabla de error asociada.

La última parte de la sentencia es que inserta en la tabla de errores cuando la sentencia genera un error.

Si ponemos REJECT LIMIT UNLIMITED Oracle insertará todo los registros erróneos en la tabla y continuará hasta que termine. Podemos limitar cuanto queramos 10,100… Oracle terminará la ejecución cuando alcance ese número de errores.

Hacemos una select de la tabla de errores:

SQL>set lines 110
SQL> col num$ for 9999999 
SQL> col ora_err_mesg$ for a50
SQL> col ora_err_rowid$ for a25
SQL> col nombre for a5
SQL> select ora_err_number$ num$, ora_err_mesg$, ora_err_rowid$, nombre from ERROR_PRUEBA
SQL> /
 

NUM$ ORA_ERR_MESG$                                      ORA_ERR_ROWID$            NOMBRE
———- ————————————————– ————————- —    
 12899 ORA-12899: value too large for column “???”.”                                      10 
           PRUEBA”.”NOMBRE” (actual: 2, maximum: 1)

Veamos una explicación de los campos de esta tabla:

NOMBRE	DESCRIPCION
ORA_ERR_NUMBER$	Error de Oracle
ORA_ERR_MESG$	Mensaje de Error
ORA_ERR_ROWID$	ROWID. En el caso del insert estará vacía, pero puede resultar de utilidad si es un update, merge o un delete
ORA_ERR_OPTYP$	El tipo de operación realizada I=INSERT, U=UPDATE, D=DELETE
ORA_ERR_TAG$	Etiqueta que podemos rellenar con información

     
Podemos controlar el número de registro insertado en el campo en el campo ORA_ERR_TAG$, ya que al ser un Insert no tenemos el rowid, recordad que los campos creados en la tabla de errores son VARCHAR2.

FOR i in 1..100
Loop
INSERT …
LOG ERRORS INTO ERROR_PRUEBA (‘Registro: ‘ || to_char(i))
    REJECT LIMIT 1;
End loop; 

Cuando hemos realizado la inserción decidiremos si realizar un commit o un rollback.

Si ejecutamos un rollback, los registros de la tabla de error no se perderán, hasta que no realicemos un trúncate de esa tabla.

Estas son los errores que podrán almacenarse en este tipo de tabla, los demás generarán un fallo y pararan la ejecución.

-       Value too large for column.

-       Constraint violations(NOT NULL, unique, referential, and check constraints).

-       Errores durante la ejecución de un trigger

-       Partition mapping errors

-       Type conversion errors arising from type conversion between a column in a subquery and the corresponding column of the table

-       A specific MERGE operation error (ORA-30926: Unable to get a stable set of rows).

Pero hay que tener en cuenta que no se puede utilizar con:

-       LONG, LOB o columnas de tipo objeto.

-       Violated deferred constraints

-       Any direct-path INSERT or MERGE operation that raises a unique constraint or index violation.

-       Any UPDATE or MERGE operation that raises a unique constraint or index violation.

-       Violation of a constraint on a LONG, LOB, or object type column

Más información sobre este paquete:

http://download-east.oracle.com/docs/cd/B19306_01/appdev.102/b14258/d_errlog.htm#ARPLS680

El gigante americano General Motors está desarrollando una tecnología de realidad aumentada mediante cámaras instaladas en el vehículo, y por ejemplo, interpretaría los límites de la carretera y los “dibujaría” en el parabrisas para ayudarnos con el trazado en casos de baja visibilidad, como  niebla, noche cerrada, etc.

Click here to view the embedded video.

Según las palabras de Thomas Seder, del departamento de investigación de General Motors:

“Imaginemos que conduces con niebla, podríamos usar las cámaras infrarrojas del vehículo para identificar dónde está el borde de la calzada y los láser para ‘pintar’ el filo de la misma en la luna, para que el conductor sepa dónde se encuentra“.

El señor Seder también nos dice que serviría para detectar obstáculos en la calzada.

Por otro lado, están buscando la manera de implementarlo de la mejor manera posible, ya que la cantidad de información mostrada en la luna delantera puede llegar a despistar:

“Todavía estamos investigando mucho sobre los efectos cognitivos de este tipo de pantalla. Tenemos que mostrar el sistema de visión mejorada como una herramienta para aumentar la información al conductor y no para distraerlos”.

Fuente: neoteo

Su precio: 19000€. Yo creo que los vale. Más información en Motion Sim.

«Las redes P2P no vulneran derecho alguno protegido por la Ley de Propiedad Intelectual»

No es la primera sentencia en este sentido, pero si es la primera desde el cambio de Ley, incomprensiblemente el gobierno sigue apoyando a la empresa (SGAE), en su intención de exprimirnos a todos cada vez que tarareamos una canción. Sería un buen momento para que el gobierno retire la ley de Economía Sostenible de la Disposición Final Primera.

La pagina de intercambio de links de redes P2P es El RincóndeJesús donde podéis ver el enlace con la sentencia.

Fuente: NeoTeo.com

“Las bases de datos relacionales, como pueden ser MySQL, PostgreSQL, Firebird u Oracle se diseñaron pensando que se ejecutaran  en una solo servidor con mucha potencia.
Jamas se penso en la posibilidad de que estuviesen distribuidas en miles de servidores.
Google creo Bigtable para que fuese, sobre todo, una base de datos en la que se almacenara una cantidad de información enorme, del orden de Peta bytes.”

Os dejo un enlace que encontré acerca de Bigtable en Linux-magazine  donde detalla su funcionamiento…

Click here to view the embedded video.

De momento sólo estará disponible en la DSi Ware japonesa, esperemos que pronto esté en occidente.

La revisión 5.0 de este tipo de tarjetas propone, en teoría, una capacidad máxima de 144petabytes. Su equivalencia vendrían a ser 144mil discos duros de 1TeraByte. Para ello, se incorporará un direccionamiento de 48bits, lo que anula la limitación de los 137GigaBytes. También se aplicarán los avances del estándar ATA, y mejora en la transferencia de datos y la limpieza de espacio no utilizado.

Fuente: neoteo