Archive

Archive for the ‘Databáze’ Category

Začínáme s JPA 2

2012-11-06 Komentáře vypnuty
  • JPA je pouze standart
  • referenční implementace: EclipseLink
  • další implementací je např. Hibernate
  1. Přidej IDEA > Tools > Data Sources
  2. Vytvoř na serveru připojení k databázi DataSource 
  3. Uprav Maven script pom.xml
    
            <!-- JPA -->
            <dependency>
                <groupId>org.eclipse.persistence</groupId>
                <artifactId>eclipselink</artifactId>
                <version>${eclipselink.version}</version>
                <scope>provided</scope>
            </dependency>
    
            <!-- EclipseLink, http://wiki.eclipse.org/EclipseLink/Maven -->
            <repository>
                <id>EclipseLink</id>
                <url>http://download.eclipse.org/rt/eclipselink/maven.repo</url>
            </repository>
    
  4. Vytvoř POJO třídu (respektive Entitu) Employee.java včetně SET a GET metod
    public class Employee {
    
        private int id;
        private String firstName;
        private String lastName;
    
    
  5. Vytvoř mapovací soubor employee.xml. Pro přehlednost vytvoř stejnou strukturu balíčků ve složce resources jakou máš ve java. Případně použij místo anotace místo xml konfigurace (odstavec na konci).
    <?xml version="1.0" encoding="UTF-8"?>
    <entity-mappings xmlns="http://java.sun.com/xml/ns/persistence/orm"
                     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
                     version="2.0">
    
        <description>The minimal mappings for a persistent entity in XML.</description>
    
        <entity name="Employee" class="com.unfuddle.kamiluv.hr.Employee" access="FIELD">
    
            <!-- Table name -->
            <table name="EMPLOYEES"/>
    
            <!-- Queries -->
            <named-query name="findAllEmployees">
                <query>SELECT e FROM Employee e</query>
            </named-query>
    
            <!-- Attributes -->
            <attributes>
                <id name="id">
                    <column name="EMPLOYEE_ID"/>
                </id>
                <basic name="firstName">
                    <column name="FIRST_NAME"/>
                </basic>
                <basic name="lastName">
                    <column name="LAST_NAME"/>
                </basic>
            </attributes>
    
        </entity>
    
    </entity-mappings>
    
    
  6. Vytvoř src\main\resources\META-INF\persistence.xml
    <?xml version="1.0" encoding="UTF-8"?>
    <persistence xmlns="http://java.sun.com/xml/ns/persistence"
                 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
                 xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd"
                 version="2.0">
    
        <persistence-unit name="WebAppPersistenceUnit" transaction-type="JTA">
            <provider>org.eclipse.persistence.jpa.PersistenceProvider</provider>
            <jta-data-source>jdbc/hr_datasource</jta-data-source>
            <mapping-file>com/wordpress/kamiluv/hr/employee.xml</mapping-file>
            <class>com.wordpress.kamiluv.hr.Employee</class>
    
            <properties>
                <property name="eclipselink.logging.level" value="INFO"/>
            </properties>
    
        </persistence-unit>
    </persistence>
    
    
    • jta-data-source odkazuje na DataSource na serveru (krok 2)
    • pokud je vše v pořádku a IntelliJ IDEA rozpozná JPA configuraci, přidá ikonky pro rychlé přecházení do POJO třídy…

  7. Vytvoř třídu EmployeeDAO
    public class EmployeeDAO {
    
        @PersistenceContext(unitName = "WebAppPersistenceUnit")
        private EntityManager em;
    
        public List<Employee> findAllEmployees() {
            TypedQuery<Employee> query = em.createNamedQuery("findAllEmployees", Employee.class);
            return query.getResultList();
        }
    }
    

Pokud dáváš přednost anotacím před xml konfigurací (bohužel se mi nepodařilo zprovoznit oboji najednou):

  • odstraň tag mapping-file z persistence.xml
  • odstraň konfigurační soubor employee.xml
  • přidej anotace do POJO třídy
    @Entity
    @NamedQuery(name = "findAllEmployees", query = "SELECT e FROM Employee e")
    @Table(name = "EMPLOYEES")
    public class Employee {
    
        @Id
        @Column(name = "EMPLOYEE_ID")
        private int id;
        @Column(name = "FIRST_NAME")
        private String firstName;
        @Column(name = "LAST_NAME")
        private String lastName;
    
        // getters & setters
    }
    

Jak importovat DataSource do GlassFish serveru

2012-11-06 Komentáře vypnuty
  • Data sources a connection pools můžeme nastavit ručně přímo ve webovém rozhraní GlassFish serveru – v Admin consoli, nebo použít script s konfigurací:
  1. Stáhni Oracle JDBC driver ojdbc6.jar a ulož jej do %GLASSFISH_HOME%\glassfish\domains\DEV\lib\ext\
  2. Zkopíruj si template %GLASSFISH_HOME%\glassfish\lib\install\templates\ resources\jdbc\oracle_type4_datasource.xml do pracovního adresáře.
  3. Přejmenuj na datasources_HR.xml a uprav:
    <resources>
        <!-- HR -->
        <jdbc-connection-pool
            name="hr_pool"
            datasource-classname="oracle.jdbc.pool.OracleDataSource"
            res-type="javax.sql.DataSource">
            <property name="url" value="jdbc:oracle:thin:@127.0.0.1:1521:XE"/>
            <property name="user" value="HR"/>
            <property name="password" value="hr"/>
        </jdbc-connection-pool>
    
        <jdbc-resource
            enabled="true"
            jndi-name="jdbc/hr_datasource"
            object-type="user"
            pool-name="hr_pool"
        />
    </resources>
    
  4. Vytvoř soubor s heslem pwd.txt:
    AS_ADMIN_PASSWORD=admin
    
  5. Vytvoř .bat script pro import:
    set GLASSFISH_HOME=c:\java\server\glassfish3
    start %GLASSFISH_HOME%\bin\asadmin --user admin --passwordfile pwd.txt --port 9000 add-resources datasources_HR.xml
    
  6. Funkčnost databázového spojení si můžeš ověřit přímo v Admin consoli nebo pomocí .bat scriptu:
    set GLASSFISH_HOME=c:\java\server\glassfish3
    start %GLASSFISH_HOME%\bin\asadmin --user admin --passwordfile pwd.txt --port 9000 ping-connection-pool hr_pool
    

Názvové konvence

2012-03-21 Komentáře vypnuty

Existuje několik různých doporučení jak pojmenovávat databázové objekty. Nezáleží však zda je použijeme nebo si vytvoříme vlastní, nejdůležitější je se jimi pevně řídit v celém projektu, protože nám usnadňují orientaci v databázovém systému. Tady je jedno z nich:

  • obecné
    • jednotné číslo
    • velká písmena
    • oddělení slov pomocí podtržítka: _
    • zkratky jen v případech, kdy je text delší než 30 znaků (nechat rezervu pro případ doplnění různých přípon)
  • Tabulky
    • název založený na jméně entity (dostatečně výstižný)
    • názvy v rámci projektu jedinečné (v případě, že projekt používá více databází)
    • nepoužívat obecné názvy jako soubor, tabulka apod.
    • nepoužívat geografické názvy apod. (lépe nad všemi daty vytvořit view EMPLOYEE_EU_VW)
  • Sloupce
    • používat název tabulky jako prefix pouze a hlavně u primárního klíče (EMPLOYEE_ID)
    • cizí klíč pojmenovat přesně podle názvu odpovídajícího sloupce primárního klíče
  • Omezení
    • TNAME_TYP_CNAME,
      • TNAME: název tabulky
      • TYP: PK | FK | UQ | CK (omezení typu check)
      • CNAME: název sloupce (sloupců), nad nímž je omezení definováno
  • Indexy
    • TNAME_TYP_CNAME
      • TNAME: název tabulky
      • TYP: UX (jedinečný index) |IX (nejedinečný index)
      • CNAME: název sloupce (sloupců), nad nímž je omezení definováno
  • Pohledy
    • NAME_VW
      • NAME: název nejdůležitější podkladové tabulky a volitelně i nějaký smysluplný text
    • název by měl smysluplně popisovat účel: EMPLOYEE_EU_VW

Source:

  • Andrew Oppel: Databáze bez předchozích znalostí
Rubriky:Databáze

Číselné typy v Javě a SQL

2012-03-13 Komentáře vypnuty
int, long & NUMBER

One paranoid delusional fear that programmers frequently have is running out of sequence numbers. Since most sequence strategies just keep incrementing a number it is unavoidable that you will eventually run out. However as long a large enough numeric precision is used to store the sequence id this is not an issue. For example if you stored your id in a NUMBER(5) column, this would allow 99,999 different ids, which on most systems would eventually run out. However if you store your id in a NUMBER(10) column, which is more typical, this would store 9,999,999,999 ids, or one id each second for about 300 years (longer than most databases exist). But perhaps your system will process a lot of data, and (hopefully) be around a very long time. If you store your id in a NUMBER(20) this would be 99,999,999,999,999,999,999 ids, or one id each millisecond for about 3,000,000,000 years, which is pretty safe.

But you also need to store this id in Java. If you store the id in a Java int, this would be a 32 bit number , which is 4,294,967,296 different ids, or one id each second for about 200 years. If you instead use a long, this would be a 64 bit number, which is 18,446,744,073,709,551,616 different ids, or one id each millisecond for about 600,000,000 years, which is pretty safe.

  • int (32 bit number, 4,294,967,296 different ids) ≈ NUMBER(10)
  • long (64 bit number, 18,446,744,073,709,551,616 different ids) ≈ NUMBER(20)
 
Source:
NUMBER vs. VARCHAR2

Q: When should I use NUMBER and when should I use VARCHAR2?

A: If you need to perform mathematical operations on a value, use NUMBER. If you are not doing math (or if the values are not used as mathematical values), store the value in a VARCHAR2.

Example: You have a data warehouse and you store an account number and a sale price. Sale price may be added or multiplied so it is NUMBER. Account number may be all numeric digits but it makes no sense to perform mathematical operations against it. Store account number as VARCHAR2.

Even if your application will not perform math against the sale price, store it as NUMBER because it makes sense to perform math against it. This is pretty much a common sense thing to me.

There is always an exception. Surrogate keys (as in sequences) – store them as a NUMBER. While you won’t be adding and subtracting them, there are benefits to storing them as a NUMBER. For one thing, you will not have to convert from numeric (result of a sequence) to string to store them.

Source:
Rubriky:Databáze, Java