Kapitel 14. Objekt-relationales Mapping (ORM) mit Hibernate bzw. Java Persistance API (JPA) Prof. Dr. Wolfgang Weber Vorlesung Datenbanken
|
|
|
- Kirsten Schmitt
- vor 6 Jahren
- Abrufe
Transkript
1 Kapitel 14 Objekt-relationales Mapping (ORM) mit Hibernate bzw. Java Persistance API (JPA) 1
2 Wozu Objekt-relationales Mapping? - Problematik - Business-Schicht OO-Klassen Unvereinbarkeit der Paradigmen Datenbank relational? 2
3 Wozu Objekt-relationales Mapping? - Problematik - Business-Schicht OO-Klassen Persistenz-Schicht Datenbank relational? 3
4 Unvereinbarkeit der Paradigmen - Lösungsmöglichkeiten - OO-Datenbanksysteme nicht durchgesetzt Abfrage und Pflege zu kompliziert alte Daten schon auf relationalen DBs gespeichert ORM Umwandlung: OO relational Frage Wie werden OO-Datenstrukturen auf relationale Datenstrukturen abgebildet? 4
5 Abbildung Typen public class { private String username; private String name; private String address; //Setter-, Getter-, Business-Methoden USERNAME varchar(50) primary key, NAME varchar(50) not null, ADDRESS varchar(100) ) 5
6 Abbildung Collections public class { private String username; private String name; private HashSet <String> address; //Setter-, Getter-, Business-Methoden USERNAME varchar(50) primary key, NAME varchar(50) not null, ADDRESS??????? ) 6
7 Abbildung Collections, Surrogatschlüssel Adresse * public class { private String username; private String name; private HashSet <String> address; //Setter-, Getter-, Business-Methoden USER_ID bigint primary key, USERNAME varchar(50) not null unique, NAME varchar(50) not null ) create table ADDRESSES ( ADDRESS_ID bigint primary key, ADDRESS varchar(100), USER_ID bigint foreign key references USERS ) 7
8 Abbildung Komposition (Collection) Adresse * public class { private String username; private String name; private HashSet <Address> address; //Setter-, Getter-, Business-Methoden public class Address { private String street; private String city; USER_ID bigint primary key, USERNAME varchar(50) not null unique, NAME varchar(50) not null ) create table ADDRESSES ( ADDRESS_ID bigint primary key, STREET varchar(50), CITY varchar(50), USER_ID bigint foreign key references USERS) 8
9 Abbildung Komposition Adresse 1 public class { private String username; private String name; private Address address; //Setter-, Getter-, Business-Methoden public class Address { private String street; private String city; USER_ID bigint primary key, USERNAME varchar(50) not null unique, NAME varchar(50) not null, ADDRESS_STREET varchar(50), ADDRESS_CITY varchar(50) ) 9
10 Abbildung 1:n-Assoziationen 1 1..* BillingDetails public class { private String username; private String name; private String address; private Set <BillingDetails> billingdetails; //Setter-, Getter-, Business-Methoden public class BillingDetails { privat String accountnumber; privat String accountname; privat String accounttype; privat user; //Setter-, Getter-, Business-Methoden USER_ID bigint primary key, USERNAME varchar(50) not null unique, NAME varchar(50) not null, ADDRESS varchar(100) ) create table BILLING_DETAILS ( BILLING_DETAILS_ID bigint primary key, ACCOUNT_NUMBER varchar (50) not null, ACCOUNT_NAME varchar (50) not null, ACCOUNT_TYPE varchar (2) not null, USER_ID bigint foreign key references USERS ) 10
11 Abbildung 1:n-Assoziationen 1 1..* BillingDetails Abbildung Datenstruktur: Wie bei 1..*-Komposition Aber: Andere Definition in Hibernate, da Navigationsrichtung in beiden Seiten da in Komposition: Löschung => Löschung Adresse 11
12 Abbildung n:m-beziehung Item 0..* hat_geboten_für 0..* public class { private String username; private String name; private Set <Item> item; //Setter-, Getter-, Business-Methoden USER_ID bigint primary key, USERNAME varchar(50) not null unique, NAME varchar(50) not null,... ) Beziehung??? public class Item { privat String description privat Set <> user; //Setter-, Getter-, Business-Methoden create table ITEM ( ITEM_ID bigint primary key, DESCRIPTION varchar(50) ) 12
13 Abbildung n:m-beziehung Item 1 0..* 1 0..* Bid public class { private String username; private String name; private Set <Item> item; //Setter-, Getter-, Business-Methoden public class Item { privart String description privat Set <> user; //Setter-, Getter-, Business-Methoden USER_ID bigint primary key, USERNAME varchar(50) not null unique, NAME varchar(50) not null,... ) create table BID ( USER_ID bigint foreign key references USER, ITEM_ID bigint foreign key references ITEM, primary key (USER_ID, ITEM_ID) ) create table ITEM ( ITEM_ID bigint primary key, DESCRIPTION varchar(50) ) 13
14 Abbildung Vererbung, Polymorphe Assoziation Abbildungsmöglichkeit 1: Eine Tabelle pro konkreter Klasse 1 1..* BillingDetails CreditCard BankAccount public class { private String username; private String name; private Set <BillingDetails> billingdetails; //Setter-, Getter-, Business-Methoden public class BillingDetails {...; privat user; public class CreditCard extends BillingDetails { privat String creditcardnumber; privat String expmonth; public class BankAccount extends BillingDetails { privat String accountnumber; USER_ID bigint primary key, USERNAME varchar(50) not null unique, NAME varchar(50) not null,... ) create table CREDIT_CARDS ( BILLING_DETAIL_ID bigint primary key, CREDIT_CARD_NUMBER varchar (50) not null unique, EXP_MONTH varchar(50) not null, USER_ID bigint foreign key references USERS,... ) create table BANK_ACCOUNT ( BILLING_DETAIL_ID bigint primary key, BANK_ACCOUNT_NUMBER varchar (50) not null, USER_ID bigint foreign key references USERS,...) 14
15 Abbildung Vererbung, Polymorphe Assoziation Abbildungsmöglichkeit 1: Eine Tabelle pro konkreter Klasse * CreditCard BillingDetails 0..* BankAccount public class { private String username; private String name; private Set <BillingDetails> billingdetails; //Setter-, Getter-, Business-Methoden public class BillingDetails {...; privat user; public class CreditCard extends BillingDetails { privat String creditcardnumber; privat String expmonth; public class BankAccount extends BillingDetails { privat String accountnumber; USER_ID bigint primary key, USERNAME varchar(50) not null unique, NAME varchar(50) not null,... ) create table CREDIT_CARDS ( BILLING_DETAIL_ID bigint primary key, CREDIT_CARD_NUMBER varchar (50) not null unique, EXP_MONTH varchar(50) not null, USER_ID bigint foreign key references USERS,... ) create table BANK_ACCOUNT ( BILLING_DETAIL_ID bigint primary key, BANK_ACCOUNT_NUMBER varchar (50) not null, USER_ID bigint foreign key references USERS,...) 15
16 Abbildung Vererbung, Polymorphe Assoziation Abbildungsmöglichkeit 1: Eine Tabelle pro konkreter Klasse * CreditCard BillingDetails 0..* BankAccount Polymorphe Abfrage von BillingDetails Abfrage über Union von CreditCard und BankAccount evtl. redundante Daten USER_ID bigint primary key, USERNAME varchar(50) not null unique, NAME varchar(50) not null,... ) create table CREDIT_CARDS ( BILLING_DETAIL_ID bigint primary key, CREDIT_CARD_NUMBER varchar (50) not null unique, EXP_MONTH varchar(50) not null, USER_ID bigint foreign key references USERS,... ) create table BANK_ACCOUNT ( BILLING_DETAIL_ID bigint primary key, BANK_ACCOUNT_NUMBER varchar (50) not null, USER_ID bigint foreign key references USERS,...) 16
17 Abbildung Vererbung, Polymorphe Assoziation Abbildungsmöglichkeit 2: Eine Tabelle pro Klassenhierarchie 1 1..* BillingDetails public class { private String username; private String name; private Set <BillingDetails> billingdetails; //Setter-, Getter-, Business-Methoden USER_ID bigint primary key, USERNAME varchar(50) not null unique, NAME varchar(50) not null,... ) public class BillingDetails {...; privat user; public class CreditCard extends BillingDetails { privat String creditcardnumber; privat String expmonth; public class BankAccount extends BillingDetails { privat String accountnumber; create table BILLING_DETAILS ( BILLING_DETAIL_ID bigint primary key, USER_ID bigint foreign key references USERS, BILLING_DETAIL_TYPE varchar(3), USER_ID varchar(50) foreign key references USERS, CREDIT_CARD_NUMBER varchar (50) not null unique, CREDIT_CARD_EXP_MONTH varchar(50) not null, BANK_ACCOUNT_NUMBER varchar (50) not null,...) 17
18 Abbildung Vererbung, Polymorphe Assoziation Abbildungsmöglichkeit 2: Eine Tabelle pro Klassenhierarchie 1 1..* BillingDetails keine Joins notwendig => sehr gute Performance not null bei Attributen aus Subklassen nicht möglich USER_ID bigint primary key, USERNAME varchar(50) not null unique, NAME varchar(50) not null,... ) create table BILLING_DETAILS ( BILLING_DETAIL_ID bigint primary key, USER_ID varchar(15) foreign key references USERS, BILLING_DETAIL_TYPE varchar(3), USER_ID varchar(50) foreign key references USERS, CREDIT_CARD_NUMBER varchar (50) not null unique, CREDIT_CARD_EXP_MONTH varchar(50) not null, BANK_ACCOUNT_NUMBER varchar (50) not null,...) 18
19 Abbildung Vererbung, Polymorphe Assoziation Abbildungsmöglichkeit 3: Eine Tabelle pro Klasse 1 1..* 0..1 CreditCard BillingDetails BankAccount public class { private String username; private String name; private Set <BillingDetails> billingdetails; //Setter-, Getter-, Business-Methoden public class BillingDetails {...; privat user; public class CreditCard extends BillingDetails { privat String creditcardnumber; privat String expmonth; public class BankAccount extends BillingDetails { privat String accountnumber; USER_ID bigint primary key USERNAME varchar(50) not null unique, NAME varchar(50) not null,... ) create table BILLING_DETAILS ( BILLING_DETAIL_ID bigint primary key, USER_ID bigint foreign key references USERS ) create table CREDIT_CARDS ( BILLING_DETAIL_ID bigint primary key foreign key references BILLING_DETAILS, CREDIT_CARD_NUMBER varchar (50) not null unique, EXP_MONTH varchar(50) not null,... ) create table BANK_ACCOUNT ( BILLING_DETAIL_ID bigint primary key, foreign key references BILLING_DETAILS, BANK_ACCOUNT_NUMBER varchar (50) not null,...) 19
20 Abbildung Vererbung, Polymorphe Assoziation Abbildungsmöglichkeit 3: Eine Tabelle pro Klasse 1 1..* 0..1 CreditCard BillingDetails BankAccount Abfrage über Joins =>schlechte Performance not null bei Attributen angebbar normalisiert keine redundante Daten USER_ID bigint primary key USERNAME varchar(50) not null unique, NAME varchar(50) not null,... ) create table BILLING_DETAILS ( BILLING_DETAIL_ID bigint primary key, USER_ID bigint foreign key references USERS ) create table CREDIT_CARDS ( BILLING_DETAIL_ID bigint primary key foreign key references BILLING_DETAILS, CREDIT_CARD_NUMBER varchar (50) not null unique, EXP_MONTH varchar(50) not null,... ) create table BANK_ACCOUNT ( BILLING_DETAIL_ID bigint primary key, foreign key references BILLING_DETAILS, BANK_ACCOUNT_NUMBER varchar (50) not null,...) 20
21 Abbildung OO relational - Wie sieht die Umsetzung in der Praxis aus? Business-Schicht OO-Klassen Persistenz-Schicht Datenbank relational 21
22 Abbildung OO relational - Wie sieht die Umsetzung in der Praxis aus? Persistenzschicht mit SQL / JDBC hardcodieren Keine Einarbeitungsaufwand in ein ORM-Tool Bei großer Anwendung sehr zeitaufwendig und bei Änderungen fehleranfällig Mit Tool unter Verwendung der Nativen Schnittstelle (z. B. von Hibernate) Schnittstelle Java Persistence API (JPA), die von ORM-Tools (u. a. auch von Hibernate) implementiert wurde. 22
23 Top-down-Vorgehensweise Klassen des OO-Domain-Modell in Java-Code oder manuell manuell Hibernate- XML-Mapping- Metadaten internes Hibernate Metamodell JPA-Schnittstelle -> Klassen des OO-Domain-Modell in Java-Code mit Mapping-Kommentaren data access objekte der Persistenzschicht relationales DB-Schema 23
24 Bottom-up-Vorgehensweise Klassen des OO-Domain-Modell in Java-Code mit Nacharbeit Hibernate- XML-Mapping- Metadaten internes Hibernate Metamodell JPA-Schnittstelle -> Klassen des OO-Domain-Modell in Java-Code mit Mapping-Kommentaren data access objekte der Persistenzschicht relationales DB-Schema 24
25 Middle-out-Vorgehensweise Klassen des OO-Domain-Modell in Java-Code Hibernate- XML-Mapping- Metadaten internes Hibernate Metamodell JPA-Schnittstelle -> Klassen des OO-Domain-Modell in Java-Code mit Mapping-Kommentaren data access objekte der Persistenzschicht relationales DB-Schema 25
26 Abbildung Komposition Adresse 1 public class { privat Long id; private String username; private String name; private Address address; () { } public (String username) { //Setter-, Getter-, Business-Meth. public class Address { private String street; private String city; USER_ID bigint primary key; USERNAME varchar(50), NAME varchar(50), ADDRESS_STREET varchar(50), ADDRESS_CITY varchar(50) ) 26
27 Abbildung Komposition über Hibernate-XML-Mapping public class { privat Long id; private String username; private String name; private Address address; public class Address { private String street; private String city; USER_ID bigint primary key; USERNAME varchar(50), NAME varchar(50), ADDRESS_STREET varchar(50), ADDRESS_CITY varchar(50)) <hibernate-mapping> <class name= table= USERS> <id name= id column= USER_ID type= long > <generator class= native /> </id> <property name= username column= USERNAME type= string /> <property name= name column= NAME type= string /> <component name= address class= Address > <property name= street column= ADDRESS_STREET type= string /> <property name= city column= ADDRESS_CITY type= string /> </component> </class> </hibernate-mapping> 27
28 Abbildung Komposition über JPA-Schnittstelle public class { privat Long id; private String username; private String name; private Address address; public class Address { private String street; private (name= USERS ) public @Column (name = USER_ID ) privat Long (name = USERNAME ) private String (name = NAME ) private String private Address address } USER_ID bigint primary key; USERNAME varchar(50), NAME varchar(50), ADDRESS_STREET varchar(50), ADDRESS_CITY varchar(50) public class Address (name = ADDRESS_STREET ) private String (name = ADDRESS_CITY ) private String city } 28
29 Definieren, Persistent machen und Lesen von Objekten // Definieren, Persistent machen von Objekten: // Öffnen von session, transaction etc. user = new ( Myname ); Long userid = (Long) session.save (user); // Schließen von transition, session; // Lesen, Ausgeben von Objekten: // Öffnen von newsession, newtransaction etc. List users = newsession.createquery(from m order by m.username asc ).list(); for ( Iterator iter=users.iterator(); iter.hasnext(); ) { loaded = () iter.next(); System.out.println (loaded.getname()) } // Schließen newtransition, newsession etc. Ausgabe: Myname new Transient.save Persistent Detached Schließen von session 29
30 Definieren, Persistent machen und Lesen von Objekten // Definieren, Persistent machen von Objekten: // Öffnen von session, transaction etc. user = new ( Myname ); Long userid = (Long) session.save (user); user.username = Weber // Schließen von transition, session; // Lesen, Ausgeben von Objekten: // Öffnen von newsession, newtransaction etc. List users = newsession.createquery(from m order by m.username asc ).list(); for ( Iterator iter=users.iterator(); iter.hasnext(); ) { loaded = () iter.next(); System.out.println (loaded.getname()) } // Schließen newtransition, newsession etc. Ausgabe: Weber new Transient.save Persistent Detached Schließen von session 30
31 . Ende Kapitel 13 31
32 Abbildung OO relational - Realisierung der Persistenzschicht mit dem Data Access Object (DAO) 32
OR-Mapping. WS2008/2009 DBIS/Dr. Karsten Tolle
OR-Mapping Zwei Paradigmen treffen aufeinander Gegensätze OO vs. Relational: Stichwort: O/R Impedance Mismatch Person Tabellen mit Schlüssel und Fremdschlusselbeziehungen. Abt-Nr. beschäftigt Pk-Nr Name
Eclipse und EclipseLink
Eclipse und EclipseLink Johannes Michler Johannes.Michler@promatis.de PROMATIS, Ettlingen Zugriff auf Oracle Datenbanken aus Eclipse RCP Anwendungen via EclipseLink 18.09.2009 1 Gliederung Eclipse als
Gregor Raschke 2008 HIBERNATE. Eine Einführung
1 HIBERNATE Eine Einführung Inhalt 2 Einleitung Beispielkonfiguration Die hibernate.cfg.xml Eine Beispieltransaktion Abfragemöglichkeiten JPA und Hibernate Ressourcen und Quellen Einleitung (1) - Geschichtliches
Hibernate. Vortragender : Nabil Janah Kursleiter : Prof. Dr. Björn Dreher Lehrveranstaltung : Komponenten-Architekturen. Nabil janah 1 Hibernate
Hibernate Vortragender : Nabil Janah Kursleiter : Prof. Dr. Björn Dreher Lehrveranstaltung : Komponenten-Architekturen Nabil janah 1 Hibernate Inhalt Hibernate allgemeines Vorteile von Hibernate Hibernate-Architektur
Analyse und praktischer Vergleich von neuen Access- Layer-Technologien in modernen Webanwendungen unter Java. Oliver Kalz
Analyse und praktischer Vergleich von neuen Access- Layer-Technologien in modernen Webanwendungen unter Java Oliver Kalz Agenda Grundlagen Objektpersistenz Objektrelationales Mapping Performance Fazit
Persistenz von Objekten relationale Datenbank Eigene Datenstruktur XML (JAXB) Proprietäre Dateiformate (Lochkarten)
Persistenz von Objekten relationale Datenbank Eigene Datenstruktur XML (JAXB) Proprietäre Dateiformate (Lochkarten) O/R Mapping - Objekte (Attribute) - 1:1, 1:n, n:m Beziehungen - Vererbungen (- Interfaces)
Das diesem Dokument zugrundeliegende Vorhaben wurde mit Mitteln des Bundesministeriums für Bildung und Forschung unter dem Förderkennzeichen
Das diesem Dokument zugrundeliegende Vorhaben wurde mit Mitteln des Bundesministeriums für Bildung und Forschung unter dem Förderkennzeichen 16OH21005 gefördert. Die Verantwortung für den Inhalt dieser
Java Persistence API 2.x. crud + relationships + jp-ql
Java Persistence API 2.x crud + relationships + jp-ql Grundprinzip 10.02.10 2 Problematik Man muss bei der Persistierung immer das Klassenmodell und dessen Umsetzung im Datenmodell (in der DB) berücksichtigen.
4. Objektrelationales Mapping Grundlagen der Programmierung II (Java)
4. Objektrelationales Mapping Grundlagen der Programmierung II (Java) Prof. Dr. Bernhard Humm Hochschule Darmstadt University of Applied Sciences Sommersemester 2006 Übersicht Grundlagen der Programmierung
Objekt-Relationale Abbildung
Lehrveranstaltung Datenbanktechnologien Prof. Dr. Ingo Claßen Prof. Dr. Martin Kempa Hochschule für Technik und Wirtschaft Berlin Objekt-Relationale Abbildung c Ingo Claßen, Martin Kempa Abbildung von
Persistenz. Ralf Gitzel
Persistenz Ralf Gitzel ralf_gitzel@hotmail.de 1 Themenübersicht Ralf Gitzel ralf_gitzel@hotmail.de 2 Übersicht Grundkonzepte Entity Beans Meine erste Entity Entity-Manager Lernziele Übungsaufgabe 3 Grundkonzepte
Programmieren II. Martin Schultheiß. Hochschule Darmstadt Sommersemester 2011
Programmieren II Martin Schultheiß Hochschule Darmstadt Sommersemester 2011 1 Objekt-relationales Mapping 2 Objekt-relationales Mapping Mit JDBC kann Java sich mit relationalen Datenbanken verbinden. Objekt-relationales
Rene Böing, Alexander Kuhn, Marc Wilmes Einführung in Spring und Hibernate
1 von 43 Rene Böing, Alexander Kuhn, Marc Wilmes Einführung in Spring und Hibernate 27.11.11 Agenda Einleitung Ist-Zustand Bookstore Was ist Hibernate? Wie funktioniert Hibernate? Was ist Spring? Architektur
Datenmanagement in Android-Apps. 16. Mai 2013
Datenmanagement in Android-Apps 16. Mai 2013 Überblick Strukturierung von datenorientierten Android-Apps Schichtenarchitektur Möglichkeiten der Datenhaltung: in Dateien, die auf der SDCard liegen in einer
Workshop Java Webentwicklung Einführung in Hibernate. Ulrich Stärk
Workshop Java Webentwicklung Einführung in Hibernate Ulrich Stärk Ablauf Montag bis Donnerstag 09:00 Uhr s.t. Beginn, bis ca. 17:00 Uhr 1 Stunde Mittagspause Donnerstag Experiment Aufzeichnung der Programmiertätigkeit
Java Forum Stuttgart 2013 Kai.Spichale@adesso.de twitter.com/kspichale spichale.blogspot.de
NoSQL für Java-Entwickler Java Forum Stuttgart 2013 Kai.Spichale@adesso.de twitter.com/kspichale spichale.blogspot.de 23.06.2013 Agenda Datengröße Key-value Stores 1. Wide Column 2. Cassandra Document
Datenbankpraktikum, Gruppe F. JPA mit Hibernate. Alexander Stautner, Harald Zauner, Sascha Schreier
JPA mit Hibernate Alexander Stautner, Harald Zauner, Sascha Schreier Agenda Objektrelationales Mapping JPA / Hibernate Demo # 2 Objektrelationales Mapping Objektorientierte Welt Objekte Objektidentität
Christian Kühl. Von JDO zu JPA Entwicklung einer Migrationsstrategie
Christian Kühl Von JDO zu JPA Entwicklung einer Migrationsstrategie Inhalt JDO und JPA Motivation Was muss migriert werden? Strategien Architektur Beispiel Migration am Beispiel Automatisierung Probleme
Softwareentwicklung mit Enterprise JAVA Beans
Softwareentwicklung mit Enterprise JAVA Beans JPA - JAVA Persistence API Problem In JAVA-programmen arbeitet man mit Hauptspeicherobjekten. Nach Beendigung des Programmes sind diese nicht mehr vorhanden.
Oracle9i Designer. Rainer Willems. Page 1. Leitender Systemberater Server Technology Competence Center Frankfurt Oracle Deutschland GmbH
Oracle9i Designer Rainer Willems Leitender Systemberater Server Technology Competence Center Frankfurt Oracle Deutschland GmbH Page 1 1 Agenda 9i Designer & 9i SCM in 9i DS Design Server Generierung &
Java Persistence Puzzlers
Die Spielregeln 1. Mappings 2. Das API 3. Abfragen Vielen Dank! Frank Schwarz, buschmais GbR Java Forum Stuttgart Java Persistence Puzzlers Wie funktioniert es? Ich frage. Sie antworten. package application;
Auf einen Blick. Abfrage und Bearbeitung. Erstellen einer Datenbank. Komplexe Abfragen. Vorwort... 13
Auf einen Blick Vorwort... 13 Teil 1 Vorbereitung Kapitel 1 Einleitung... 17 Kapitel 2 SQL der Standard relationaler Datenbanken... 21 Kapitel 3 Die Beispieldatenbanken... 39 Teil 2 Abfrage und Bearbeitung
Inhaltsverzeichnis. Vorwort Kapitel 1 Einleitung... 15
Vorwort..................................................... 13 Kapitel 1 Einleitung.......................................... 15 Kapitel 2 SQL der Standard relationaler Datenbanken... 19 2.1 Die Geschichte................................
Auf einen Blick. Abfrage und Bearbeitung. Erstellen einer Datenbank. Komplexe Abfragen. Vorwort 13
Auf einen Blick Vorwort 13 Teil 1 Vorbereitung Kapitel 1 Einleitung 17 Kapitel 2 SQL - der Standard relationaler Datenbanken 21 Kapitel 3 Die Beispieldatenbanken 39 Teil 2 Abfrage und Bearbeitung Kapitel
Kein blasses Schema? NoSQL und Big Data mit Hibernate OGM
Kein blasses Schema? NoSQL und Big Data mit Hibernate OGM Thomas Much thomas@muchsoft.com www.muchsoft.com 1 NoSQL und Big Data Herzlich Willkommen in der NoSQL-Welt OnlySQL Not 2 NoSQL und Big Data NoSQL
Inhaltsverzeichnis. Vorwort 13. Kapitel 1 Einleitung 15
Vorwort 13 Kapitel 1 Einleitung 15 Kapitel 2 SQL-der Standard relationaler Datenbanken... 19 2.1 Die Geschichte 19 2.2 Die Bestandteile 20 2.3 Die Verarbeitung einer SQL-Anweisung 22 2.4 Die Struktur von
Java Persistence mit Hibernate
Christian Bauer, Gavin King Java Persistence mit Hibernate ISBN-10: 3-446-40941-6 ISBN-13: 978-3-446-40941-5 Inhaltsverzeichnis Weitere Informationen oder Bestellungen unter http://www.hanser.de/978-3-446-40941-5
Datenbanken. Zusammenfassung. Datenbanksysteme
Zusammenfassung Datenbanksysteme Christian Moser Seite 1 vom 7 12.09.2002 Wichtige Begriffe Attribut Assoziation API Atomares Attribut Datenbasis DBMS Datenunabhängigkeit Datenbankmodell DDL DML DCL ER-Diagramm
6 Implementierung komplexer Systeme. 6.2 Datenbank-Anbindung
6 Implementierung komplexer Systeme 6.2 Datenbank-Anbindung Analyse Entwurf Implementierung Test, Integration Wartung Literatur: Balzert LE 24-26, 31 Ambler Kap. 10 Einsatz von Datenbanksystemen Persistente
ISU 1. Ue_08/02_Datenbanken/SQL. 08 Datenbanken. Übung. SQL Einführung. Eckbert Jankowski. www.iit.tu-cottbus.de
08 Datenbanken Übung SQL Einführung Eckbert Jankowski www.iit.tu-cottbus.de Datenmodell (Wiederholung, Zusammenfassung) Objekte und deren Eigenschaften definieren Beziehungen zwischen den Objekten erkennen/definieren
Übungsaufgaben zur Klausurvorbereitung Datenbanken 2, SoSe 2016
Die nachfolgenden Aufgaben sind nach Kategorien geordnet und stellen eine Auswahl von Aufgaben aus alten Klausuren des bisherigen Bachelor-WP-Fachs Datenbank Anwendungsentwicklung dar. Kategorie 1: OR-Mapping
Technische Fachhochschule Berlin, FB VI - Medieninformatik Software Engineering (SE II), 2. Kapitel: Wir bauen uns eine Web-Applikation.
Kapitel WIR BAUEN UNS EINE WEB-APPLIKATION (ZWEITER TEIL) 2.5 Persistente Klassen mit JPA (Zweite Fingerübung) Entity Relationship-Modell Die persistente Klasse Inventory () Ein Attribut der Klasse zum
Oracle native json Support. Erste Schritte
Oracle native json Support Erste Schritte 1 Ausgangslage Als erster Schritt erstellen wir eine Tabelle, die wir für den weiteren Verlauf brauchen werden. Die Felder Id, Created und Username sind normale
Relationales Modell: SQL-DDL. SQL als Definitionssprache. 7. Datenbankdefinitionssprachen. Anforderungen an eine relationale DDL
Relationales Modell: SQLDDL SQL als Definitionssprache SQLDDL umfaßt alle Klauseln von SQL, die mit Definition von Typen Wertebereichen Relationenschemata Integritätsbedingungen zu tun haben Externe Ebene
Hibernate Das Praxisbuch für Entwickler
Sebastian Hennebrüder 2008 AGI-Information Management Consultants May be used for personal purporses only or by libraries associated to dandelon.com network. Hibernate Das Praxisbuch für Entwickler Galileo
pmmda.net 1 Content Ojb.Net NHibernate Gentle.Net Fazit... 4
1 Content 1 Content... 1 2 Ojb.Net... 1 3 NHibernate... 2 4 Gentle.Net... 3 5 Fazit... 4 2 Ojb.Net Dokumentation http://ojb-net.sourceforge.net Ojb.Net ist die Portierung des Apache Projektes ojb. Die
Objektorientierte Datenbanken
OODB 8 Slide 1 Objektorientierte Datenbanken Vorlesung 8 Sebastian Iwanowski FH Wedel OODB 8 Slide 2 Offene Fragen vom letzten Mal: Kann man in einer JDOQL-Anfrage Elemente herausfiltern, deren Attribute
10. Datenbank Design 1
1 Die Hauptaufgabe einer Datenbank besteht darin, Daten so lange zu speichern bis diese explizit überschrieben oder gelöscht werden. Also auch über das Ende (ev. sogar der Lebenszeit) einer Applikation
Datenbanken Unit 9: OLAP, OLTP und objektrelationale Datenbanken
Datenbanken Unit 9: OLAP, OLTP und objektrelationale Datenbanken 17. V. 2017 Outline 1 Organisatorisches 2 SQL 3 OLTP, OLAP, SAP, and Data Warehouse OLTP and OLAP SAP 4 Objekt-relationale Datenbanken Beispiel
Quick Start HSQLDB/Hibernate.
Quick Start HSQLDB/Hibernate http://www.hsqldb.org/ http://hibernate.org/orm/ HyperSQL http://sourceforge.net/projects/hsqldb/files/latest/ download?source=files Zip-Datei hsqldb.jar in classpath legen
Grails. Weiterführende Themen zu Internet- und WWW-Technologien. Matthias Springer. 06. Juni 2011
Weiterführende Themen zu Internet- und WWW-Technologien 06. Juni 2011 Übersicht 1 Was ist? 2 Übersicht über 3 MVC-Konzept 4 Groovy Beispiele 5 Tutorial: Kleiner Notizblock Web Application Framework Übersicht
SQL Tutorial. SQL - Tutorial SS 06. Hubert Baumgartner. INSO - Industrial Software
SQL Tutorial SQL - Tutorial SS 06 Hubert Baumgartner INSO - Industrial Software Institut für Rechnergestützte Automation Fakultät für Informatik Technische Universität Wien Inhalt des Tutorials 1 2 3 4
TU München, Fakultät für Informatik Lehrstuhl III: Datenbanksysteme Prof. Alfons Kemper, Ph.D.
TU München, Fakultät für Informatik Lehrstuhl III: Datenbanksysteme Prof. Alfons Kemper, Ph.D. Übung zur Vorlesung Einführung in die Informatik 2 für Ingenieure (MSE) Alexander van Renen (renen@in.tum.de)
Referent: Marko Modsching. Vortrag: JPA mit Hibernate. Datum: 04.01.2011. Deutsche Software Engineering & Research GmbH
Referent: Marko Modsching Vortrag: JPA mit Hibernate Datum: 04.01.2011 Deutsche Software Engineering & Research GmbH Steinstraße 11 02826 Görlitz Germany Telefon: +49 35 81 / 374 99 0 Telefax: +49 35 81
OO Programmiersprache vs relationales Model. DBIS/Dr. Karsten Tolle
OO Programmiersprache vs relationales Model Vorgehen bisher Erstellen eines ER-Diagramms Übersetzen in das relationale Datenmodell Zugriff auf das relationale Datenmodell aus z.b. Java ER rel. Modell OO
Bibliografische Informationen digitalisiert durch http://d-nb.info/995021198
Auf einen Blick 1 Einleitung 15 2 Datenbankentwurf 23 3 Datenbankdefinition 43 4 Datensätze einfügen (INSERT INTO) 95 5 Daten abfragen (SELECT) 99 6 Daten aus mehreren Tabellen abfragen (JOIN) 143 7 Unterabfragen
Programmieren II. Objekt-relationales Mapping. Vorlesung 08. Handout S. 1. Martin Schultheiß. Hochschule Darmstadt Sommersemester 2011
Programmieren II Martin Schultheiß Hochschule Darmstadt Sommersemester 2011 1 / 39 2 / 39 Mit JDBC kann Java sich mit relationalen Datenbanken verbinden. Hierbei entsprechen jeder Datensatz einer Zeile
Steffen Hofmann Freie Universität Berlin ZEDAT Identity and Customer Management (ICM) Aktueller Stand Shibboleth IdP3
Steffen Hofmann Freie Universität Berlin ZEDAT Identity and Customer Management (ICM) Aktueller Stand Shibboleth IdP3 Übersicht Bericht vom Shibboleth IdP3 Installationssprint in Berlin Planung nächster
Vesant JDO Genie für transparente Persistenz mit relationalen Datenbanken.
Vesant JDO Genie für transparente Persistenz mit relationalen Datenbanken. Martin Wessel Senior Pre-Sales Consultant Versant GmbH mailto: Martin.Wessel@versant.net Copyright Versant Europe 2004. All products
Hibernate. Objekt/Relationales Mapping für Java
Hibernate Objekt/Relationales Mapping für Java Wer bin ich? Stefan Wille Softwareentwickler / Architekt seit 1996 Freelancer seit 2000 Autor von Goto JavaServer Pages in 2001 Wesentliche Themen Was ist
Introduction to Data and Knowledge Engineering. 6. Übung SQL
Introduction to Data and Knowledge Engineering 6. Übung SQL Aufgabe 6.1 Datenbank-Schema Buch PK FK Autor PK FK ISBN Titel Preis x ID Vorname Nachname x BuchAutor ISBN ID PK x x FK Buch.ISBN Autor.ID FB
Hibernate Search. Unterstützung laufender Java Projekte. Perfect Match Rent-a-team Coaching on the project Inhouse Outsourcing
Orientation in Objects GmbH Weinheimer Str. 68 68309 Mannheim Version: 1.0 www.oio.de info@oio.de Java, XML und Open Source seit 1998 ) Software Factory ) ) Object Rangers ) ) Competence Center) Schlüsselfertige
7. XML-Datenbanksysteme und SQL/XML
7. XML-Datenbanksysteme und SQL/XML Native XML-DBS vs. XML-Erweiterungen von ORDBS Speicherung von XML-Dokumenten Speicherung von XML-Dokumenten als Ganzes Generische Dekomposition von XML-Dokumenten Schemabasierte
Objektorientierte Datenbanken
OODB 11 Slide 1 Objektorientierte Datenbanken Vorlesung 11 Sebastian Iwanowski FH Wedel OODB 11 Slide 2 Wesentliche Eigenschaften von Hibernate Transparente Persistenz Transitive Persistenz (Persistenz
4. Datenbanksprache SQL
4. Datenbanksprache SQL Standard-Sprache für das Arbeiten mit relationalen Datenbanken: Structured Query Language Datendefinition: Anlegen, Ändern und Löschen von Datenbankstrukturen Datenmanipulation:
Object Relational Mapping Layer
Object Relational Mapping Layer Dr. Christian Senger ORM & Vererbung 1 create table fortbildung( id number primary key, bezeichnung varchar2(40), datum date ); create table themenblock( id number primary
Objekt-relationales Mapping und Performance-Tuning
Objekt-relationales Mapping und Performance-Tuning Thomas Krüger tkrueger@vanatec.com Agenda Wege um Daten zu lesen Wege um Daten zu modellieren Wege um Datenbanken effizient zu nutzen 2 2 Wege, Daten
Effizienzsteigerung durch Mapping- Tools bei der Integration von RDBMS in Java-Anwendungen
Effizienzsteigerung durch Mapping- Tools bei der Integration von RDBMS in Java-Anwendungen ARS NOVA Software GmbH Klaus Kiehne Java Forum, 28. Juni, 9:45-10:30 1 Inhalt Aufgaben und Fähigkeiten Einsatz-
Java Connectivity mit Caché extreme (Persist & Perform ohne Umwege) Gerd Nachtsheim, Senior Sales Engineer, InterSystems
Java Connectivity mit Caché extreme (Persist & Perform ohne Umwege) Gerd Nachtsheim, Senior Sales Engineer, InterSystems InterSystems Unternehmensprofil Internationales Softwareunternehmen Hauptsitz in
Wiederholung VU Datenmodellierung
Wiederholung VU Datenmodellierung VU Datenbanksysteme Reinhard Pichler Arbeitsbereich Datenbanken und Artificial Intelligence Institut für Informationssysteme Technische Universität Wien Wintersemester
Treffpunkt Semicolon. NoSQL. mit JPA und Hibernate OGM. Thomas Much 09.09.2014
Treffpunkt Semicolon NoSQL mit JPA und Hibernate OGM Thomas Much 09.09.2014 Über... Thomas Much Dipl.-Inform. (Universität Karlsruhe (TH)) Berater, Architekt, Entwickler, Coach (seit 1990) Trainer für
Willkommen. Datenbanken und Anbindung
Willkommen Datenbanken und Anbindung Welche stehen zur Wahl? MySQL Sehr weit verbreitetes DBS (YT, FB, Twitter) Open-Source und Enterprise-Version Libs in C/C++ und Java verfügbar Grundsätzlich ist ein
Daten Bank. 6. Vorlesung
Daten Bank 6. Vorlesung Prinzipien des digitalen Speicherns I Ein Datensatz sollte offensichtlich/eindeutig und schnell mit dem Objekt, welches es repräsentiert, in Verbindung gebracht werden können. ISBN
SQL structured query language
Umfangreiche Datenmengen werden üblicherweise in relationalen Datenbank-Systemen (RDBMS) gespeichert Logische Struktur der Datenbank wird mittels Entity/Realtionship-Diagrammen dargestellt structured query
Java Persistenz mit JPA und Hibernate. Michael Plöd - Senacor Technologies AG
Java Persistenz mit JPA und Hibernate Michael Plöd - Senacor Technologies AG Michael Plöd Partner bei Senacor Technologies AG Hibernate Erfahrung seit 2002 michael.ploed@senacor.com Ihr Hintergrund Erfahrung
ORM & OLAP. Object-oriented Enterprise Application Programming Model for In-Memory Databases. Sebastian Oergel
ORM & OLAP Object-oriented Enterprise Application Programming Model for In-Memory Databases Sebastian Oergel Probleme 2 Datenbanken sind elementar für Business-Anwendungen Gängiges Datenbankparadigma:
Das Leben der Anderen
Das Leben der Anderen Twitter-Analyse mit Oracle12c, JSON und APEX Carsten Czarski Business Unit Database Oracle Deutschland B.V. & Co KG About: Carsten Czarski 1973 München Verheiratet zwei Kinder ORACLE
4.2 Workshop EJB. Entwicklung von EJB-Anwendungen
4.2 Workshop EJB Entwicklung von EJB-Anwendungen Welche Schritte werden benötigt, bis eine verteilte EJB-Anwendung einsatzbereit ist? Was muss alles implementiert werden? An welchen Stellen unterstützt
Grundlagen von SQL. Informatik 2, FS18. Dr. Hermann Lehner (Material von Dr. Markus Dahinden) Departement Informatik, ETH Zürich
Grundlagen von SQL Informatik 2, FS18 Dr. Hermann Lehner (Material von Dr. Markus Dahinden) Departement Informatik, ETH Zürich Markus Dahinden 13.05.18 1 Grundlagen von SQL (Structured Query Language)
Pitfalls. Flush and Clear: O/R Mapping Pitfalls. Mirko Novakovic, codecentric GmbH
Flush and Clear: O/R Mapping Pitfalls Flush and Clear: O/R Mapping Pitfalls Mirko Novakovic, codecentric GmbH Agenda Einleitung Pitfalls Faul oder Eifrig Daten verstecken Spülen und Reinigen Fragen? Performance
Datenbanken Unit 9: OLAP, OLTP und objektrelationale Datenbanken
Datenbanken Unit 9: OLAP, OLTP und objektrelationale Datenbanken 31. V. 2016 Outline 1 Organisatorisches 2 SQL 3 OLTP, OLAP, SAP, and Data Warehouse OLTP and OLAP SAP 4 Objekt-relationale Datenbanken Beispiel
Datenbanken. Seminararbeit. Einführung in das wissenschaftliche Arbeiten
Seminararbeit vorgelegt von: Gutachter: Studienbereich: Christian Lechner Dr. Georg Moser Informatik Datum: 6. Juni 2013 Inhaltsverzeichnis Inhaltsverzeichnis 1 Einführung in Datenbanken 1 1.1 Motivation....................................
<Insert Picture Here> Generierung von ADF-Applikationen aus Metadaten des Oracle Designer
Generierung von ADF-Applikationen aus Metadaten des Oracle Designer Jürgen Menge Oracle Deutschland Oracle Designer - Metadaten Investment vieler Anwender liegt in den Metadaten des
Oracle 10g Einführung
Kurs Oracle 10g Einführung Teil 5 Einführung Timo Meyer Administration von Oracle-Datenbanken Timo Meyer Sommersemester 2006 Seite 1 von 16 Seite 1 von 16 Agenda 1 Tabellen und Views erstellen 2 Indizes
XML in der Oracle Datenbank
XML in der Oracle Datenbank Oracle XML DB Eine kurze Einführung Gruppe A Michaela Geierhos Galina Hinova Maximilian Schöfmann AGENDA Warum XML in einer Datenbank? Was bietet die Oracle XML DB? Unterschiedliche
Relationales Datenbanksystem Oracle
Relationales Datenbanksystem Oracle 1 Relationales Modell Im relationalen Modell wird ein relationales Datenbankschema wie folgt beschrieben: RS = R 1 X 1 SC 1... R n X n SC n SC a a : i=1...n X i B Information
Überschreiben von Methoden
Vergleich der DoME Realisierungen: Methode ausgeben Version 1 (ohne Vererbung): Anzeigen aller Informationen CD: A Swingin Affair (64 Min)* Frank Sinatra Titelanzahl: 16 Mein Lieblingsalbum von Sinatra
Enterprise JavaBeans Überblick: 10. Queries Interface Query 10.2 EJB Query Language 10.3 Named Queries
Enterprise JavaBeans Überblick 1. Überblick Komponententechnologien 2. Einführung 3. Enterprise JavaBeans Architektur 4. Ressourcen Management und Primäre Services 5. Java Persistence: Entity Manager 6.
Open-Source Transparente Persistence (keine Interfaces, keine Ober- Klassen) Caching
1 Was ist Hibernate Hibernate ist ein Open-Source-Java-Persistenz-Framework für relationale Datenbanken Persistenz-Frameworks: kapseln und abstrahiert den Zugriff auf eine Speicherschicht -> Zwischenschicht
Übung 01 Tabellen erstellen
UEB-01-1 Übung 01 Tabellen erstellen Die folgende Musterrechnung dokumentiert eine Miniwelt "Rechnung" in einer Firma. 1. Welche Objekte und Beziehungen lassen sich daraus ableiten? 2. Erstellen Sie ein
Nachtrag: Farben. Farbblindheit. (Light und Bartlein 2004)
Nachtrag: Farben Farbblindheit (Light und Bartlein 2004) 1 Vorgeschlagene Farbskalen (Light and Bartlein 2004) Farbkodierung metrisch skalierter Daten Unterscheide: 1. Sequential Data (ohne Betonung der
DATENBANKEN SQL UND SQLITE VON MELANIE SCHLIEBENER
DATENBANKEN SQL UND SQLITE VON MELANIE SCHLIEBENER INHALTSVERZEICHNIS 1. Datenbanken 2. SQL 1.1 Sinn und Zweck 1.2 Definition 1.3 Modelle 1.4 Relationales Datenbankmodell 2.1 Definition 2.2 Befehle 3.
Einteilung von Datenbanken
Datenbanksysteme (c) A.Kaiser; WU-Wien 1 Einteilung von Datenbanken 1. formatierte Datenbanken 2. unformatierte Datenbanken Information Retrieval Systeme 2 Wozu Datenbanken? Speicherung und Verwaltung
Object Relational Mapping Layer
Object Relational Mapping Layer Views Controlers Business logic GUI OO-application logic Object-relational-Mapping Relational DBMS PHP (propel) 1/18 Propel - Persistance Layer OR-Mapper für PHP Portierung
NoSQL Datenbanken EIN ÜBERBLICK ÜBER NICHT-RELATIONALE DATENBANKEN UND DEREN POTENTIALE IM ALLGEMEINEN UND IN DER INDUSTRIE
NoSQL Datenbanken EIN ÜBERBLICK ÜBER NICHT-RELATIONALE DATENBANKEN UND DEREN POTENTIALE IM ALLGEMEINEN UND IN DER INDUSTRIE Was bedeutet NoSQL? Ein Sammelbegriff für alternative Datenbanklösungen, die
Inhalt. Ein Einführung in die Nutzung von SQL-Datenbanken am Beispiel Oracle. Daten und Tabellen - ein Beispiel. Daten und Tabellen - Normalisierung
Inhalt Ein Einführung in die Nutzung von SQL-Datenbanken am Beispiel Oracle Daten und Tabellen Normalisierung, Beziehungen, Datenmodell SQL - Structured Query Language Anlegen von Tabellen Datentypen (Spalten,
SODA. Die Datenbank als Document Store. Rainer Willems. Master Principal Sales Consultant Oracle Deutschland B.V. & Co. KG
SODA Die Datenbank als Document Store Rainer Willems Master Principal Sales Consultant Oracle Deutschland B.V. & Co. KG vs No Anforderungskonflikte Agile Entwicklung Häufige Schema-Änderungen Relationales
7. Datenbankdefinitionssprachen
7. Datenbankdefinitionssprachen SQL-DDL Teil der Standardsprache für relationale Datenbanksysteme: SQL ODL (Object Definition Language) für objektorientierte Datenbanksysteme nach dem ODMG-Standard VL
ORACLE Business Components for Java (BC4J) Marco Grawunder
ORACLE Business Components for Java (BC4J) Marco Grawunder Gliederung 2 Probleme von J2EE/EJB J2EE-Pattern Lösungsansatz: BC4J Architektur einer BC4J-Anwendung Komponenten Entity Objects View Objects Application
JDO Java Data Objects
JDO Java Data Objects Ralf Degner, Chief Consultant Ralf.Degner@poet.de Agenda POET Motivation Geschichte Einführung Architekturen FastObjects POET Gegründet 1993 Zwei Produktlinien esupplier Solutions:
Kapitel 3: Datenbanksysteme
LUDWIG- MAXIMILIANS- UNIVERSITY MUNICH DEPARTMENT INSTITUTE FOR INFORMATICS Skript zur Vorlesung: Einführung in die Informatik: Systeme und Anwendungen Sommersemester 2008 Kapitel 3: Datenbanksysteme Vorlesung:
MOF Meta Object Facility. Veranstaltungsvortrag im Rahmen der Projektgruppe ComponentTools
MOF Meta Object Facility Veranstaltungsvortrag im Rahmen der Projektgruppe ComponentTools Überblick Object Management Group (OMG) Model Driven Architecture (MDA) Exkurs: Modelle, Metamodelle MOF Architektur
XML in der Oracle Datenbank "relational and beyond"
XML in der Oracle Datenbank "relational and beyond" Ulrike Schwinn (Ulrike.Schwinn@oracle.com) Oracle Deutschland GmbH Oracle XML DB Ein Überblick 1-1 Agenda Warum XML in der Datenbank? Unterschiedliche
Einführung in SQL. Sprachumfang: Indizes. Datensätzen. Zugriffsrechten
Einführung in SQL Die Sprache SQL (Structured Query Language) ist eine Programmiersprache für relationale Datenbanksysteme, die auf dem ANSI-SQL-Standard beruht. SQL wird heute von fast jedem Datenbanksystem
Kapitel 3: Datenbanksysteme
LUDWIG- MAXIMILIANS- UNIVERSITY MUNICH DEPARTMENT INSTITUTE FOR INFORMATICS Skript zur : Einführung in die Informatik: Systeme und Anwendungen Sommersemester 2009 Kapitel 3: Datenbanksysteme : PDDr. Peer
Eine neue Datenbank erstellen
Eine neue Datenbank erstellen Eine neue Datenbank erstellen Eine Tabelle in der Entwurfsansicht erstellen Eine Tabelle in der Entwurfsansicht erstellen Eine Tabelle in der Entwurfsansicht erstellen Das
Software Engineering. 8. Persistenz
Software Engineering 8. Persistenz Gliederung Vorlesung Einführung V-Modell XT Analyse und Anforderungsmanagement Benutzungsoberflächen Architektur Entwurf Entwurfsmuster Persistenz Implementierung Konfigurationsmanagement
Webbasierte Informationssysteme
SS 2004 Prof. Dr. Stefan Böttcher Universität Paderborn - SS 2004 - Prof. Dr. Stefan Böttcher Folie 1 Was ist eine relationale Datenbank? Menge von Relationen (=Tabellen) und Constraints (=Integritätsbedingungen)
4. Objektrelationales Typsystem Kollektionstypen. Nested Table
Nested Table Bei einer Nested Table handelt es sich um eine Tabelle als Attributwert. Im Gegensatz zu Varray gibt es keine Beschränkung bei der Größe. Definition erfolgt auf einem Basistyp, als Basistypen
MySQL, phpmyadmin & SQL. Kurzübersicht
MySQL, phpmyadmin & SQL Kurzübersicht Referenzen MySQL Documentation: http://dev.mysql.com/doc PHP 5 / MySQL5. Studienausgabe. Praxisbuch und Referenz (Kannengießer & Kannengießer) 2 Datenbank anlegen