SQL ist eine Sprache zum Betreiben von Datenbanken. Es umfasst das Erstellen, Löschen, Abrufen von Zeilen, Ändern von Zeilen usw. der DatenbankANSI Standardsprache (American National Standards Institute), aber es gibt viele verschiedene Versionen der SQL-Sprache.

Was ist SQL?

SQL ist eine strukturierte Abfragesprache, eine Computersprache zum Speichern, Bearbeiten und Abrufen von Daten, die in einer relationalen Datenbank gespeichert sind.

SQL ist die Standardsprache für das relationale Datenbanksystem. Alle relationalen Datenbankverwaltungssysteme (RDMS) wie MySQL, MS Access, Oracle, Sybase, Informix, Postgres und SQL Server verwenden SQL als Standarddatenbanksprache.

Außerdem verwenden sie verschiedene Dialekte, wie z.

• MS SQL Server mit T-SQL,
• Oracle mit PL / SQL,
• Die MS Access-Version von SQL heißt JET SQL (natives Format) usw.

Warum SQL?

SQL ist weit verbreitet, da es die folgenden Vorteile bietet:

• Ermöglicht Benutzern den Zugriff auf Daten in den relationalen Datenbankverwaltungssystemen.

• Ermöglicht Benutzern die Beschreibung der Daten.

• Ermöglicht Benutzern das Definieren der Daten in einer Datenbank und das Bearbeiten dieser Daten.

• Ermöglicht das Einbetten in andere Sprachen mithilfe von SQL-Modulen, Bibliotheken und Pre-Compilern.

• Ermöglicht Benutzern das Erstellen und Löschen von Datenbanken und Tabellen.

• Ermöglicht Benutzern das Erstellen von Ansichten, gespeicherten Prozeduren und Funktionen in einer Datenbank.

• Ermöglicht Benutzern das Festlegen von Berechtigungen für Tabellen, Prozeduren und Ansichten.

Eine kurze Geschichte von SQL

• 1970- Dr. Edgar F. "Ted" Codd von IBM ist als Vater relationaler Datenbanken bekannt. Er beschrieb ein relationales Modell für Datenbanken.

• 1974 - Strukturierte Abfragesprache wurde angezeigt.

• 1978 - IBM arbeitete an der Entwicklung der Ideen von Codd und veröffentlichte ein Produkt namens System / R.

• 1986- IBM hat den ersten Prototyp einer relationalen Datenbank entwickelt und von ANSI standardisiert. Die erste relationale Datenbank wurde von Relational Software veröffentlicht, die später als Oracle bekannt wurde.

SQL-Prozess

Wenn Sie einen SQL-Befehl für ein RDBMS ausführen, bestimmt das System, wie Ihre Anforderung am besten ausgeführt werden kann, und die SQL-Engine ermittelt, wie die Aufgabe zu interpretieren ist.

In diesem Prozess sind verschiedene Komponenten enthalten.

Diese Komponenten sind -

• Abfrage-Dispatcher
• Optimierungsmotoren
• Klassische Abfrage-Engine
• SQL Query Engine usw.

Eine klassische Abfrage-Engine verarbeitet alle Nicht-SQL-Abfragen, eine SQL-Abfrage-Engine verarbeitet jedoch keine logischen Dateien.

Das folgende Diagramm zeigt die SQL-Architektur:

SQL-Befehle

Die Standard-SQL-Befehle für die Interaktion mit relationalen Datenbanken sind CREATE, SELECT, INSERT, UPDATE, DELETE und DROP. Diese Befehle können je nach Art in die folgenden Gruppen eingeteilt werden:

DDL - Data Definition Language

Sr.Nr.	Befehl & Beschreibung
1	CREATE Erstellt eine neue Tabelle, eine Ansicht einer Tabelle oder ein anderes Objekt in der Datenbank.
2	ALTER Ändert ein vorhandenes Datenbankobjekt, z. B. eine Tabelle.
3	DROP Löscht eine gesamte Tabelle, eine Ansicht einer Tabelle oder andere Objekte in der Datenbank.

DML - Data Manipulation Language

Sr.Nr.	Befehl & Beschreibung
1	SELECT Ruft bestimmte Datensätze aus einer oder mehreren Tabellen ab.
2	INSERT Erstellt einen Datensatz.
3	UPDATE Ändert Datensätze.
4	DELETE Löscht Datensätze.

DCL - Data Control Language

Sr.Nr.	Befehl & Beschreibung
1	GRANT Gibt dem Benutzer ein Privileg.
2	REVOKE Nimmt vom Benutzer gewährte Berechtigungen zurück.

Was ist RDBMS?

RDBMS steht für Relational Database MManagement System. RDBMS ist die Basis für SQL und für alle modernen Datenbanksysteme wie MS SQL Server, IBM DB2, Oracle, MySQL und Microsoft Access.

Ein relationales Datenbankverwaltungssystem (RDBMS) ist ein Datenbankverwaltungssystem (DBMS), das auf dem von EF Codd eingeführten relationalen Modell basiert.

Was ist ein Tisch?

Die Daten in einem RDBMS werden in Datenbankobjekten gespeichert, die als aufgerufen werden tables. Diese Tabelle ist im Grunde eine Sammlung verwandter Dateneinträge und besteht aus zahlreichen Spalten und Zeilen.

Denken Sie daran, dass eine Tabelle die häufigste und einfachste Form der Datenspeicherung in einer relationalen Datenbank ist. Das folgende Programm ist ein Beispiel für eine CUSTOMERS-Tabelle -

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Was ist ein Feld?

Jede Tabelle ist in kleinere Entitäten unterteilt, die als Felder bezeichnet werden. Die Felder in der Tabelle CUSTOMERS bestehen aus ID, NAME, ALTER, ADRESSE und GEHALT.

Ein Feld ist eine Spalte in einer Tabelle, die bestimmte Informationen zu jedem Datensatz in der Tabelle enthält.

Was ist ein Datensatz oder eine Zeile?

Ein Datensatz wird auch als Datenzeile bezeichnet. Dies ist jeder einzelne Eintrag, der in einer Tabelle vorhanden ist. Zum Beispiel enthält die obige Tabelle CUSTOMERS 7 Datensätze. Es folgt eine einzelne Daten- oder Datensatzzeile in der Tabelle CUSTOMERS -

+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
+----+----------+-----+-----------+----------+

Ein Datensatz ist eine horizontale Entität in einer Tabelle.

Was ist eine Spalte?

Eine Spalte ist eine vertikale Entität in einer Tabelle, die alle Informationen enthält, die einem bestimmten Feld in einer Tabelle zugeordnet sind.

Eine Spalte in der Tabelle CUSTOMERS ist beispielsweise ADDRESS, die die Standortbeschreibung darstellt und wie folgt aussieht:

+-----------+
| ADDRESS   |
+-----------+
| Ahmedabad |
| Delhi     |
| Kota      |
| Mumbai    |
| Bhopal    |
| MP        |
| Indore    |
+----+------+

Was ist ein NULL-Wert?

Ein NULL-Wert in einer Tabelle ist ein Wert in einem Feld, der leer zu sein scheint. Dies bedeutet, dass ein Feld mit einem NULL-Wert ein Feld ohne Wert ist.

Es ist sehr wichtig zu verstehen, dass sich ein NULL-Wert von einem Nullwert oder einem Feld mit Leerzeichen unterscheidet. Ein Feld mit einem NULL-Wert wurde während der Datensatzerstellung leer gelassen.

SQL-Einschränkungen

Einschränkungen sind die Regeln, die für Datenspalten in einer Tabelle gelten. Diese werden verwendet, um den Datentyp zu begrenzen, der in eine Tabelle aufgenommen werden kann. Dies stellt die Genauigkeit und Zuverlässigkeit der Daten in der Datenbank sicher.

Einschränkungen können entweder Spalten- oder Tabellenebene sein. Einschränkungen auf Spaltenebene werden nur auf eine Spalte angewendet, während Einschränkungen auf Tabellenebene auf die gesamte Tabelle angewendet werden.

Im Folgenden sind einige der am häufigsten verwendeten Einschränkungen aufgeführt, die in SQL verfügbar sind:

• NOT NULL-Einschränkung - Stellt sicher, dass eine Spalte keinen NULL-Wert haben kann.

• DEFAULT Constraint - Stellt einen Standardwert für eine Spalte bereit, wenn keiner angegeben ist.

• EINZIGARTIGE Einschränkung - Stellt sicher, dass alle Werte in einer Spalte unterschiedlich sind.

• PRIMARY-Schlüssel - Identifiziert jede Zeile / jeden Datensatz in einer Datenbanktabelle eindeutig.

• AUSLÄNDISCHER Schlüssel - Identifiziert eine Zeile / einen Datensatz in einer anderen Datenbanktabelle eindeutig.

• CHECK-Einschränkung - Die CHECK-Einschränkung stellt sicher, dass alle Werte in einer Spalte bestimmte Bedingungen erfüllen.

• INDEX - Wird verwendet, um Daten sehr schnell zu erstellen und aus der Datenbank abzurufen.

Datenintegrität

Die folgenden Kategorien der Datenintegrität existieren für jedes RDBMS:

• Entity Integrity − Eine Tabelle enthält keine doppelten Zeilen.

• Domain Integrity − Erzwingt gültige Einträge für eine bestimmte Spalte, indem der Typ, das Format oder der Wertebereich eingeschränkt werden.

• Referential integrity − Zeilen, die von anderen Datensätzen verwendet werden, können nicht gelöscht werden.

• User-Defined Integrity − Erzwingt bestimmte Geschäftsregeln, die nicht in die Integrität von Entitäten, Domänen oder Referenzen fallen.

Datenbanknormalisierung

Bei der Datenbanknormalisierung werden Daten in einer Datenbank effizient organisiert. Es gibt zwei Gründe für diesen Normalisierungsprozess:

• Eliminieren Sie redundante Daten, indem Sie beispielsweise dieselben Daten in mehr als einer Tabelle speichern.

• Sicherstellen, dass Datenabhängigkeiten sinnvoll sind.

Beide Gründe sind würdige Ziele, da sie den Speicherplatz einer Datenbank reduzieren und sicherstellen, dass Daten logisch gespeichert werden. Die Normalisierung besteht aus einer Reihe von Richtlinien, die Sie beim Erstellen einer guten Datenbankstruktur unterstützen.

Normalisierungsrichtlinien sind in normale Formen unterteilt. Stellen Sie sich ein Formular als das Format oder die Art und Weise vor, wie eine Datenbankstruktur aufgebaut ist. Das Ziel von Normalformularen besteht darin, die Datenbankstruktur so zu organisieren, dass sie den Regeln der ersten Normalform, der zweiten Normalform und schließlich der dritten Normalform entspricht.

Sie haben die Wahl, weiter zu gehen und zur vierten Normalform, zur fünften Normalform usw. zu wechseln. Im Allgemeinen ist die dritte Normalform jedoch mehr als ausreichend.

• Erste Normalform (1NF)
• Zweite Normalform (2NF)
• Dritte Normalform (3NF)

Es gibt viele beliebte RDBMS, mit denen Sie arbeiten können. Dieses Tutorial gibt einen kurzen Überblick über einige der beliebtesten RDBMS. Dies würde Ihnen helfen, ihre Grundfunktionen zu vergleichen.

MySQL

MySQL ist eine Open-Source-SQL-Datenbank, die von einem schwedischen Unternehmen - MySQL AB - entwickelt wurde. MySQL wird als "my ess-que-ell" ausgesprochen, im Gegensatz zu SQL als "Fortsetzung".

MySQL unterstützt viele verschiedene Plattformen, darunter Microsoft Windows, die wichtigsten Linux-Distributionen, UNIX und Mac OS X.

MySQL bietet kostenlose und kostenpflichtige Versionen, abhängig von der Verwendung (nicht kommerziell / kommerziell) und den Funktionen. MySQL wird mit einem sehr schnellen, Multithread-, Mehrbenutzer- und robusten SQL-Datenbankserver geliefert.

Geschichte

• Entwicklung von MySQL durch Michael Widenius & David Axmark ab 1994.

• Erste interne Freigabe am 23. ^rd Mai 1995.

• Windows - Version wurde am 8. veröffentlicht ^th Januar 1998 für Windows 95 und NT.

• Version 3.23: Beta ab Juni 2000, Produktionsfreigabe Januar 2001.

• Version 4.0: Beta ab August 2002, Produktionsfreigabe März 2003 (Gewerkschaften).

• Version 4.1: Beta ab Juni 2004, Produktionsfreigabe Oktober 2004.

• Version 5.0: Beta ab März 2005, Produktionsfreigabe Oktober 2005.

• Sun Microsystems erworben MySQL AB am 26. ^th Februar 2008.

• Version 5.1: Produktions - Release 27 ^th November 2008.

Eigenschaften

• Hochleistung.
• Hohe Verfügbarkeit.
• Skalierbarkeit und Flexibilität Führen Sie alles aus.
• Robuste Transaktionsunterstützung.
• Stärken von Web und Data Warehouse.
• Starker Datenschutz.
• Umfassende Anwendungsentwicklung.
• Einfache Verwaltung.
• Open Source Freedom und 24 x 7 Support.
• Niedrigste Gesamtbetriebskosten.

MS SQL Server

MS SQL Server ist ein relationales Datenbankverwaltungssystem, das von Microsoft Inc. entwickelt wurde. Die primären Abfragesprachen sind:

• T-SQL
• ANSI SQL

Geschichte

• 1987 - Sybase veröffentlicht SQL Server für UNIX.

• 1988 - Microsoft, Sybase und Aston-Tate portieren SQL Server auf OS / 2.

• 1989 - Microsoft, Sybase und Aston-Tate veröffentlichen SQL Server 1.0 für OS / 2.

• 1990 - SQL Server 1.1 wird mit Unterstützung für Windows 3.0-Clients veröffentlicht.

• Aston - Tate bricht die SQL Server-Entwicklung ab.

• 2000 - Microsoft veröffentlicht SQL Server 2000.

• 2001 - Microsoft veröffentlicht XML für SQL Server Web Release 1 (Download).

• 2002 - Microsoft veröffentlicht SQLXML 2.0 (von XML für SQL Server umbenannt).

• 2002 - Microsoft veröffentlicht SQLXML 3.0.

• 2005 - Microsoft veröffentlicht SQL Server 2005 am 7. November 2005.

Eigenschaften

• Hochleistung
• Hohe Verfügbarkeit
• Datenbankspiegelung
• Datenbank-Snapshots
• CLR-Integration
• Service Broker
• DDL wird ausgelöst
• Ranking-Funktionen
• Zeilenversionsbasierte Isolationsstufen
• XML-Integration
• TRY...CATCH
• Datenbank-Mail

ORAKEL

Es ist ein sehr großes mehrbenutzerbasiertes Datenbankverwaltungssystem. Oracle ist ein relationales Datenbankverwaltungssystem, das von der Oracle Corporation entwickelt wurde.

Oracle arbeitet an der effizienten Verwaltung seiner Ressourcen, einer Datenbank mit Informationen zwischen mehreren Clients, die Daten im Netzwerk anfordern und senden.

Es ist eine ausgezeichnete Wahl für Datenbankserver für Client / Server-Computing. Oracle unterstützt alle wichtigen Betriebssysteme für Clients und Server, einschließlich MSDOS, NetWare, UnixWare, OS / 2 und die meisten UNIX-Varianten.

Geschichte

Oracle begann 1977 und feierte seine 32 wundervollen Jahre in der Branche (von 1977 bis 2009).

• 1977 - Larry Ellison, Bob Miner und Ed Oates gründen Software Development Laboratories, um Entwicklungsarbeiten durchzuführen.

• 1979 - Version 2.0 von Oracle wurde veröffentlicht und wurde die erste kommerzielle relationale Datenbank und die erste SQL-Datenbank. Das Unternehmen änderte seinen Namen in Relational Software Inc. (RSI).

• 1981 - RSI beginnt mit der Entwicklung von Tools für Oracle.

• 1982 - RSI wurde in Oracle Corporation umbenannt.

• 1983 - Oracle veröffentlicht Version 3.0, in C-Sprache umgeschrieben und auf mehreren Plattformen ausgeführt.

• 1984 - Oracle Version 4.0 wurde veröffentlicht. Es enthielt Funktionen wie Parallelitätskontrolle - Lesekonsistenz für mehrere Versionen usw.

• 1985 - Oracle Version 4.0 wurde veröffentlicht. Es enthielt Funktionen wie Parallelitätskontrolle - Lesekonsistenz für mehrere Versionen usw.

• 2007 - Oracle veröffentlicht Oracle11g. Die neue Version konzentrierte sich auf eine bessere Partitionierung, einfache Migration usw.

Eigenschaften

• Concurrency
• Konsistenz lesen
• Verriegelungsmechanismen
• Ruhe-Datenbank
• Portability
• Selbstverwaltende Datenbank
• SQL*Plus
• ASM
• Scheduler
• Ressourcenmanager
• Data Warehousing
• Materialisierte Ansichten
• Bitmap-Indizes
• Tabellenkomprimierung
• Parallele Ausführung
• Analytisches SQL
• Data Mining
• Partitioning

MS ACCESS

Dies ist eines der beliebtesten Microsoft-Produkte. Microsoft Access ist eine Einstiegs-Datenbankverwaltungssoftware. Die MS Access-Datenbank ist nicht nur kostengünstig, sondern auch eine leistungsstarke Datenbank für kleine Projekte.

MS Access verwendet das Jet-Datenbankmodul, das einen bestimmten Dialekt in SQL-Sprache verwendet (manchmal auch als Jet SQL bezeichnet).

MS Access wird mit der Professional Edition des MS Office-Pakets geliefert. MS Access verfügt über eine benutzerfreundliche, intuitive grafische Oberfläche.

• 1992 - Access Version 1.0 wurde veröffentlicht.

• 1993 - Access 1.1 wird veröffentlicht, um die Kompatibilität mit der Aufnahme der Programmiersprache Access Basic zu verbessern.

• Der wichtigste Übergang war von Access 97 zu Access 2000.

• 2007 - Access 2007, ein neues Datenbankformat, ACCDB, das komplexe Datentypen wie mehrwertige Felder und Anhangsfelder unterstützt.

Eigenschaften

• Benutzer können Tabellen, Abfragen, Formulare und Berichte erstellen und diese mit Makros verbinden.

• Option zum Importieren und Exportieren der Daten in viele Formate, einschließlich Excel, Outlook, ASCII, dBase, Paradox, FoxPro, SQL Server, Oracle, ODBC usw.

• Es gibt auch das Jet-Datenbankformat (MDB oder ACCDB in Access 2007), das die Anwendung und die Daten in einer Datei enthalten kann. Dies macht es sehr bequem, die gesamte Anwendung an einen anderen Benutzer zu verteilen, der sie in nicht verbundenen Umgebungen ausführen kann.

• Microsoft Access bietet parametrisierte Abfragen. Diese Abfragen und Zugriffstabellen können von anderen Programmen wie VB6 und .NET über DAO oder ADO referenziert werden.

• Die Desktop-Editionen von Microsoft SQL Server können mit Access als Alternative zum Jet Database Engine verwendet werden.

• Microsoft Access ist eine Dateiserver-basierte Datenbank. Im Gegensatz zu den relationalen Client-Server-Datenbankverwaltungssystemen (RDBMS) implementiert Microsoft Access keine Datenbankauslöser, gespeicherten Prozeduren oder Transaktionsprotokollierung.

SQL - Syntax

Auf SQL folgt ein eindeutiger Satz von Regeln und Richtlinien namens Syntax. Dieses Tutorial bietet Ihnen einen schnellen Einstieg in SQL, indem Sie alle grundlegenden SQL-Syntaxen auflisten.

Alle SQL-Anweisungen beginnen mit einem der Schlüsselwörter wie SELECT, INSERT, UPDATE, DELETE, ALTER, DROP, CREATE, USE, SHOW und alle Anweisungen enden mit einem Semikolon (;).

Der wichtigste Punkt, der hier beachtet werden muss, ist, dass bei SQL die Groß- und Kleinschreibung nicht berücksichtigt wird. Dies bedeutet, dass SELECT und select in SQL-Anweisungen dieselbe Bedeutung haben. Während MySQL bei Tabellennamen einen Unterschied macht. Wenn Sie also mit MySQL arbeiten, müssen Sie Tabellennamen angeben, wie sie in der Datenbank vorhanden sind.

Verschiedene Syntax in SQL

Alle Beispiele in diesem Tutorial wurden mit einem MySQL-Server getestet.

SQL SELECT-Anweisung

SELECT column1, column2....columnN
FROM   table_name;

SQL DISTINCT-Klausel

SELECT DISTINCT column1, column2....columnN
FROM   table_name;

SQL WHERE-Klausel

SELECT column1, column2....columnN
FROM   table_name
WHERE  CONDITION;

SQL AND / OR-Klausel

SELECT column1, column2....columnN
FROM   table_name
WHERE  CONDITION-1 {AND|OR} CONDITION-2;

SQL IN-Klausel

SELECT column1, column2....columnN
FROM   table_name
WHERE  column_name IN (val-1, val-2,...val-N);

SQL ZWISCHEN Klausel

SELECT column1, column2....columnN
FROM   table_name
WHERE  column_name BETWEEN val-1 AND val-2;

SQL LIKE-Klausel

SELECT column1, column2....columnN
FROM   table_name
WHERE  column_name LIKE { PATTERN };

SQL ORDER BY-Klausel

SELECT column1, column2....columnN
FROM   table_name
WHERE  CONDITION
ORDER BY column_name {ASC|DESC};

SQL GROUP BY-Klausel

SELECT SUM(column_name)
FROM   table_name
WHERE  CONDITION
GROUP BY column_name;

SQL COUNT-Klausel

SELECT COUNT(column_name)
FROM   table_name
WHERE  CONDITION;

SQL HAVING-Klausel

SELECT SUM(column_name)
FROM   table_name
WHERE  CONDITION
GROUP BY column_name
HAVING (arithematic function condition);

SQL CREATE TABLE-Anweisung

CREATE TABLE table_name(
column1 datatype,
column2 datatype,
column3 datatype,
.....
columnN datatype,
PRIMARY KEY( one or more columns )
);

SQL DROP TABLE-Anweisung

DROP TABLE table_name;

SQL CREATE INDEX-Anweisung

CREATE UNIQUE INDEX index_name
ON table_name ( column1, column2,...columnN);

SQL DROP INDEX-Anweisung

ALTER TABLE table_name
DROP INDEX index_name;

SQL DESC-Anweisung

DESC table_name;

SQL TRUNCATE TABLE-Anweisung

TRUNCATE TABLE table_name;

SQL ALTER TABLE-Anweisung

ALTER TABLE table_name {ADD|DROP|MODIFY} column_name {data_ype};

SQL ALTER TABLE-Anweisung (Umbenennen)

ALTER TABLE table_name RENAME TO new_table_name;

SQL INSERT INTO-Anweisung

INSERT INTO table_name( column1, column2....columnN)
VALUES ( value1, value2....valueN);

SQL UPDATE-Anweisung

UPDATE table_name
SET column1 = value1, column2 = value2....columnN=valueN
[ WHERE  CONDITION ];

SQL DELETE-Anweisung

DELETE FROM table_name
WHERE  {CONDITION};

SQL CREATE DATABASE-Anweisung

CREATE DATABASE database_name;

SQL DROP DATABASE-Anweisung

DROP DATABASE database_name;

SQL USE-Anweisung

USE database_name;

SQL COMMIT-Anweisung

COMMIT;

SQL ROLLBACK-Anweisung

ROLLBACK;

SQL - Datentypen

SQL-Datentyp ist ein Attribut, das den Datentyp eines Objekts angibt. Jede Spalte, Variable und jeder Ausdruck hat in SQL einen verwandten Datentyp. Sie können diese Datentypen beim Erstellen Ihrer Tabellen verwenden. Sie können je nach Anforderung einen Datentyp für eine Tabellenspalte auswählen.

SQL Server bietet sechs Kategorien von Datentypen für Ihre Verwendung, die unten aufgeführt sind:

Genaue numerische Datentypen

DATENTYP	VON	ZU
Bigint	-9,223,372,036,854,775,808	9,223,372,036,854,775,807
int	-2,147,483,648	2,147,483,647
smallint	-32.768	32.767
tinyint	0	255
bisschen	0	1
Dezimal	-10 ^ 38 +1	10 ^ 38 -1
numerisch	-10 ^ 38 +1	10 ^ 38 -1
Geld	-922.337.203.685.477.5808	+922.337.203.685.477.5807
Kleingeld	-214.748,3648	+214.748,3647

Ungefähre numerische Datentypen

DATENTYP	VON	ZU
schweben	-1,79E + 308	1,79E + 308
echt	-3,40E + 38	3,40E + 38

Datums- und Uhrzeitdatentypen

DATENTYP	VON	ZU
Terminzeit	1. Januar 1753	31. Dezember 9999
kleine Zeit	1. Januar 1900	6. Juni 2079
Datum	Speichert ein Datum wie den 30. Juni 1991
Zeit	Speichert eine Tageszeit wie 12:30 Uhr

Note - Hier hat datetime eine Genauigkeit von 3,33 Millisekunden, während smalldatetime eine Genauigkeit von 1 Minute hat.

Datentypen für Zeichenfolgen

Sr.Nr.	DATENTYP & Beschreibung
1	char Maximale Länge von 8.000 Zeichen (Nicht-Unicode-Zeichen mit fester Länge)
2	varchar Maximal 8.000 Zeichen (Nicht-Unicode-Daten variabler Länge).
3	varchar(max) Maximale Länge von 2E + 31 Zeichen, Nicht-Unicode-Daten variabler Länge (nur SQL Server 2005).
4	text Nicht-Unicode-Daten variabler Länge mit einer maximalen Länge von 2.147.483.647 Zeichen.

Datentypen für Unicode-Zeichenfolgen

Sr.Nr.	DATENTYP & Beschreibung
1	nchar Maximale Länge von 4.000 Zeichen. (Unicode mit fester Länge)
2	nvarchar Maximale Länge von 4.000 Zeichen (Unicode mit variabler Länge)
3	nvarchar(max) Maximale Länge von 2E + 31 Zeichen (nur SQL Server 2005) (Unicode mit variabler Länge)
4	ntext Maximale Länge von 1.073.741.823 Zeichen. (Unicode variabler Länge)

Binäre Datentypen

Sr.Nr.	DATENTYP & Beschreibung
1	binary Maximale Länge von 8.000 Bytes (Binärdaten mit fester Länge)
2	varbinary Maximale Länge von 8.000 Bytes (Binärdaten variabler Länge)
3	varbinary(max) Maximale Länge von 2E + 31 Byte (nur SQL Server 2005). (Binärdaten variabler Länge)
4	image Maximale Länge von 2.147.483.647 Bytes. (Binärdaten variabler Länge)

Verschiedene Datentypen

Sr.Nr.	DATENTYP & Beschreibung
1	sql_variant Speichert Werte verschiedener von SQL Server unterstützter Datentypen außer Text, ntext und Zeitstempel.
2	timestamp Speichert eine datenbankweite eindeutige Nummer, die jedes Mal aktualisiert wird, wenn eine Zeile aktualisiert wird
3	uniqueidentifier Speichert eine global eindeutige Kennung (GUID)
4	xml Speichert XML-Daten. Sie können XML-Instanzen in einer Spalte oder einer Variablen speichern (nur SQL Server 2005).
5	cursor Verweis auf ein Cursorobjekt
6	table Speichert eine Ergebnismenge für die spätere Verarbeitung

SQL - Operatoren

Was ist ein Operator in SQL?

Ein Operator ist ein reserviertes Wort oder ein Zeichen, das hauptsächlich in der WHERE-Klausel einer SQL-Anweisung verwendet wird, um Operationen auszuführen, z. B. Vergleiche und arithmetische Operationen. Diese Operatoren werden verwendet, um Bedingungen in einer SQL-Anweisung anzugeben und als Konjunktionen für mehrere Bedingungen in einer Anweisung zu dienen.

• Rechenzeichen
• Vergleichsoperatoren
• Logische Operatoren
• Operatoren, mit denen Bedingungen negiert werden

SQL-Arithmetikoperatoren

Annehmen 'variable a' hält 10 und 'variable b' hält 20, dann -

Beispiele anzeigen

Operator	Beschreibung	Beispiel
+ (Ergänzung)	Fügt Werte auf beiden Seiten des Operators hinzu.	a + b ergibt 30
- (Subtraktion)	Subtrahiert den rechten Operanden vom linken Operanden.	a - b ergibt -10
* (Multiplikation)	Multipliziert Werte auf beiden Seiten des Operators.	a * b ergibt 200
/ (Teilung)	Teilt den linken Operanden durch den rechten Operanden.	b / a ergibt 2
% (Modul)	Teilt den linken Operanden durch den rechten Operanden und gibt den Rest zurück.	b% a ergibt 0

SQL-Vergleichsoperatoren

Annehmen 'variable a' hält 10 und 'variable b' hält 20, dann -

Beispiele anzeigen

Operator	Beschreibung	Beispiel
=	Überprüft, ob die Werte von zwei Operanden gleich sind oder nicht. Wenn ja, wird die Bedingung wahr.	(a = b) ist nicht wahr.
! =	Überprüft, ob die Werte von zwei Operanden gleich sind oder nicht. Wenn die Werte nicht gleich sind, wird die Bedingung wahr.	(a! = b) ist wahr.
<>	Überprüft, ob die Werte von zwei Operanden gleich sind oder nicht. Wenn die Werte nicht gleich sind, wird die Bedingung wahr.	(a <> b) ist wahr.
>	Überprüft, ob der Wert des linken Operanden größer als der Wert des rechten Operanden ist. Wenn ja, wird die Bedingung wahr.	(a> b) ist nicht wahr.
<	Überprüft, ob der Wert des linken Operanden kleiner als der Wert des rechten Operanden ist. Wenn ja, wird die Bedingung wahr.	(a <b) ist wahr.
> =	Überprüft, ob der Wert des linken Operanden größer oder gleich dem Wert des rechten Operanden ist. Wenn ja, wird die Bedingung wahr.	(a> = b) ist nicht wahr.
<=	Überprüft, ob der Wert des linken Operanden kleiner oder gleich dem Wert des rechten Operanden ist. Wenn ja, wird die Bedingung wahr.	(a <= b) ist wahr.
! <	Überprüft, ob der Wert des linken Operanden nicht kleiner als der Wert des rechten Operanden ist. Wenn ja, wird die Bedingung wahr.	(a! <b) ist falsch.
!>	Überprüft, ob der Wert des linken Operanden nicht größer als der Wert des rechten Operanden ist. Wenn ja, wird die Bedingung wahr.	(a!> b) ist wahr.

Logische SQL-Operatoren

Hier ist eine Liste aller in SQL verfügbaren logischen Operatoren.

Beispiele anzeigen

Sr.Nr.	Betreiber & Beschreibung
1	ALL Der ALL-Operator wird verwendet, um einen Wert mit allen Werten in einem anderen Wertesatz zu vergleichen.
2	AND Der AND-Operator ermöglicht das Vorhandensein mehrerer Bedingungen in der WHERE-Klausel einer SQL-Anweisung.
3	ANY Der ANY-Operator wird verwendet, um einen Wert gemäß der Bedingung mit einem anwendbaren Wert in der Liste zu vergleichen.
4	BETWEEN Der Operator BETWEEN wird verwendet, um nach Werten zu suchen, die innerhalb eines Satzes von Werten liegen, wobei der Minimalwert und der Maximalwert angegeben werden.
5	EXISTS Der EXISTS-Operator wird verwendet, um nach dem Vorhandensein einer Zeile in einer angegebenen Tabelle zu suchen, die ein bestimmtes Kriterium erfüllt.
6	IN Der IN-Operator wird verwendet, um einen Wert mit einer Liste der angegebenen Literalwerte zu vergleichen.
7	LIKE Der LIKE-Operator wird verwendet, um einen Wert mit Platzhalteroperatoren mit ähnlichen Werten zu vergleichen.
8	NOT Der NOT-Operator kehrt die Bedeutung des logischen Operators um, mit dem er verwendet wird. ZB: NICHT EXISTIERT, NICHT ZWISCHEN, NICHT IN usw.This is a negate operator.
9	OR Der OR-Operator wird verwendet, um mehrere Bedingungen in der WHERE-Klausel einer SQL-Anweisung zu kombinieren.
10	IS NULL Der NULL-Operator wird verwendet, um einen Wert mit einem NULL-Wert zu vergleichen.
11	UNIQUE Der UNIQUE-Operator durchsucht jede Zeile einer angegebenen Tabelle nach Eindeutigkeit (keine Duplikate).

SQL - Ausdrücke

Ein Ausdruck ist eine Kombination aus einem oder mehreren Werten, Operatoren und SQL-Funktionen, die zu einem Wert ausgewertet werden. Diese SQL-AUSDRÜCKE sind wie Formeln und in Abfragesprache geschrieben. Sie können sie auch verwenden, um die Datenbank nach einem bestimmten Datensatz abzufragen.

Syntax

Betrachten Sie die grundlegende Syntax der SELECT-Anweisung wie folgt:

SELECT column1, column2, columnN 
FROM table_name 
WHERE [CONDITION|EXPRESSION];

Es gibt verschiedene Arten von SQL-Ausdrücken, die unten aufgeführt sind:

• Boolean
• Numeric
• Date

Lassen Sie uns nun jeden dieser Punkte im Detail besprechen.

Boolesche Ausdrücke

SQL Boolean Expressions rufen die Daten basierend auf der Übereinstimmung mit einem einzelnen Wert ab. Es folgt die Syntax -

SELECT column1, column2, columnN 
FROM table_name 
WHERE SINGLE VALUE MATCHING EXPRESSION;

Betrachten Sie die Tabelle CUSTOMERS mit den folgenden Datensätzen:

SQL> SELECT * FROM CUSTOMERS;
+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+
7 rows in set (0.00 sec)

Die folgende Tabelle ist ein einfaches Beispiel für die Verwendung verschiedener boolescher SQL-Ausdrücke.

SQL> SELECT * FROM CUSTOMERS WHERE SALARY = 10000;
+----+-------+-----+---------+----------+
| ID | NAME  | AGE | ADDRESS | SALARY   |
+----+-------+-----+---------+----------+
|  7 | Muffy |  24 | Indore  | 10000.00 |
+----+-------+-----+---------+----------+
1 row in set (0.00 sec)

Numerischer Ausdruck

Diese Ausdrücke werden verwendet, um eine beliebige mathematische Operation in einer Abfrage auszuführen. Es folgt die Syntax -

SELECT numerical_expression as  OPERATION_NAME
[FROM table_name
WHERE CONDITION] ;

Hier wird der numerische Ausdruck für einen mathematischen Ausdruck oder eine beliebige Formel verwendet. Das folgende Beispiel zeigt die Verwendung von numerischen SQL-Ausdrücken:

SQL> SELECT (15 + 6) AS ADDITION
+----------+
| ADDITION |
+----------+
|       21 |
+----------+
1 row in set (0.00 sec)

Es gibt mehrere integrierte Funktionen wie avg (), sum (), count () usw., um sogenannte Aggregatdatenberechnungen für eine Tabelle oder eine bestimmte Tabellenspalte durchzuführen.

SQL> SELECT COUNT(*) AS "RECORDS" FROM CUSTOMERS; 
+---------+
| RECORDS |
+---------+
|       7 |
+---------+
1 row in set (0.00 sec)

Datumsausdrücke

Datumsausdrücke geben aktuelle Datums- und Zeitwerte des Systems zurück -

SQL>  SELECT CURRENT_TIMESTAMP;
+---------------------+
| Current_Timestamp   |
+---------------------+
| 2009-11-12 06:40:23 |
+---------------------+
1 row in set (0.00 sec)

Ein weiterer Datumsausdruck ist wie folgt:

SQL>  SELECT  GETDATE();;
+-------------------------+
| GETDATE                 |
+-------------------------+
| 2009-10-22 12:07:18.140 |
+-------------------------+
1 row in set (0.00 sec)

SQL - CREATE-Datenbank

Die SQL CREATE DATABASE Anweisung wird verwendet, um eine neue SQL-Datenbank zu erstellen.

Syntax

Die grundlegende Syntax dieser CREATE DATABASE-Anweisung lautet wie folgt:

CREATE DATABASE DatabaseName;

Der Datenbankname sollte innerhalb des RDBMS immer eindeutig sein.

Beispiel

Wenn Sie eine neue Datenbank <testDB> erstellen möchten, lautet die Anweisung CREATE DATABASE wie folgt:

SQL> CREATE DATABASE testDB;

Stellen Sie sicher, dass Sie über die Administratorrechte verfügen, bevor Sie eine Datenbank erstellen. Sobald eine Datenbank erstellt wurde, können Sie sie in der Liste der Datenbanken wie folgt überprüfen:

SQL> SHOW DATABASES;
+--------------------+
| Database           |
+--------------------+
| information_schema |
| AMROOD             |
| TUTORIALSPOINT     |
| mysql              |
| orig               |
| test               |
| testDB             |
+--------------------+
7 rows in set (0.00 sec)

SQL - DROP oder DELETE Datenbank

Die SQL DROP DATABASE Die Anweisung wird verwendet, um eine vorhandene Datenbank im SQL-Schema zu löschen.

Syntax

Die grundlegende Syntax der DROP DATABASE-Anweisung lautet wie folgt:

DROP DATABASE DatabaseName;

Der Datenbankname sollte innerhalb des RDBMS immer eindeutig sein.

Beispiel

Wenn Sie eine vorhandene Datenbank <testDB> löschen möchten, lautet die Anweisung DROP DATABASE wie folgt:

SQL> DROP DATABASE testDB;

NOTE - Seien Sie vorsichtig, bevor Sie diesen Vorgang ausführen, da das Löschen einer vorhandenen Datenbank zum Verlust vollständiger Informationen führen würde, die in der Datenbank gespeichert sind.

Stellen Sie sicher, dass Sie über die Administratorrechte verfügen, bevor Sie eine Datenbank löschen. Sobald eine Datenbank gelöscht wurde, können Sie sie in der Liste der Datenbanken wie unten gezeigt überprüfen.

SQL> SHOW DATABASES;
+--------------------+
| Database           |
+--------------------+
| information_schema |
| AMROOD             |
| TUTORIALSPOINT     |
| mysql              |
| orig               |
| test               |
+--------------------+
6 rows in set (0.00 sec)

SQL - SELECT Datenbank, USE Anweisung

Wenn Ihr SQL-Schema mehrere Datenbanken enthält, müssen Sie vor dem Starten des Vorgangs eine Datenbank auswählen, in der alle Vorgänge ausgeführt werden.

Die SQL USE Die Anweisung wird verwendet, um eine vorhandene Datenbank im SQL-Schema auszuwählen.

Syntax

Die grundlegende Syntax der USE-Anweisung lautet wie folgt:

USE DatabaseName;

Der Datenbankname sollte innerhalb des RDBMS immer eindeutig sein.

Beispiel

Sie können die verfügbaren Datenbanken wie unten gezeigt überprüfen -

SQL> SHOW DATABASES;
+--------------------+
| Database           |
+--------------------+
| information_schema |
| AMROOD             |
| TUTORIALSPOINT     |
| mysql              |
| orig               |
| test               |
+--------------------+
6 rows in set (0.00 sec)

Wenn Sie jetzt mit der AMROOD-Datenbank arbeiten möchten, können Sie den folgenden SQL-Befehl ausführen und mit der AMROOD-Datenbank arbeiten.

SQL> USE AMROOD;

SQL - CREATE-Tabelle

Das Erstellen einer Basistabelle umfasst das Benennen der Tabelle und das Definieren ihrer Spalten und des Datentyps jeder Spalte.

Die SQL CREATE TABLE Anweisung wird verwendet, um eine neue Tabelle zu erstellen.

Syntax

Die grundlegende Syntax der Anweisung CREATE TABLE lautet wie folgt:

CREATE TABLE table_name(
   column1 datatype,
   column2 datatype,
   column3 datatype,
   .....
   columnN datatype,
   PRIMARY KEY( one or more columns )
);

CREATE TABLE ist das Schlüsselwort, das dem Datenbanksystem mitteilt, was Sie tun möchten. In diesem Fall möchten Sie eine neue Tabelle erstellen. Der eindeutige Name oder Bezeichner für die Tabelle folgt der Anweisung CREATE TABLE.

In Klammern steht dann die Liste, in der jede Spalte in der Tabelle und der Datentyp definiert sind. Die Syntax wird anhand des folgenden Beispiels klarer.

Eine Kopie einer vorhandenen Tabelle kann mithilfe einer Kombination aus der Anweisung CREATE TABLE und der Anweisung SELECT erstellt werden. Sie können die vollständigen Details unter Tabelle mit einer anderen Tabelle erstellen überprüfen .

Beispiel

Der folgende Codeblock ist ein Beispiel, das eine CUSTOMERS-Tabelle mit einer ID als Primärschlüssel erstellt. NOT NULL sind die Einschränkungen, die zeigen, dass diese Felder beim Erstellen von Datensätzen in dieser Tabelle nicht NULL sein dürfen.

SQL> CREATE TABLE CUSTOMERS(
   ID   INT              NOT NULL,
   NAME VARCHAR (20)     NOT NULL,
   AGE  INT              NOT NULL,
   ADDRESS  CHAR (25) ,
   SALARY   DECIMAL (18, 2),       
   PRIMARY KEY (ID)
);

Sie können überprüfen, ob Ihre Tabelle erfolgreich erstellt wurde, indem Sie sich die vom SQL Server angezeigte Nachricht ansehen. Andernfalls können Sie die verwenden DESC Befehl wie folgt -

SQL> DESC CUSTOMERS;
+---------+---------------+------+-----+---------+-------+
| Field   | Type          | Null | Key | Default | Extra |
+---------+---------------+------+-----+---------+-------+
| ID      | int(11)       | NO   | PRI |         |       |
| NAME    | varchar(20)   | NO   |     |         |       |
| AGE     | int(11)       | NO   |     |         |       |
| ADDRESS | char(25)      | YES  |     | NULL    |       |
| SALARY  | decimal(18,2) | YES  |     | NULL    |       |
+---------+---------------+------+-----+---------+-------+
5 rows in set (0.00 sec)

Jetzt steht in Ihrer Datenbank die Tabelle CUSTOMERS zur Verfügung, in der Sie die erforderlichen Informationen zu Kunden speichern können.

SQL - DROP oder DELETE Tabelle

Die SQL DROP TABLE Die Anweisung wird verwendet, um eine Tabellendefinition und alle Daten, Indizes, Trigger, Einschränkungen und Berechtigungsspezifikationen für diese Tabelle zu entfernen.

NOTE - Sie sollten bei der Verwendung dieses Befehls sehr vorsichtig sein, da nach dem Löschen einer Tabelle alle in dieser Tabelle verfügbaren Informationen für immer verloren gehen.

Syntax

Die grundlegende Syntax dieser DROP TABLE-Anweisung lautet wie folgt:

DROP TABLE table_name;

Beispiel

Lassen Sie uns zuerst die CUSTOMERS-Tabelle überprüfen und sie dann wie unten gezeigt aus der Datenbank löschen.

SQL> DESC CUSTOMERS;
+---------+---------------+------+-----+---------+-------+
| Field   | Type          | Null | Key | Default | Extra |
+---------+---------------+------+-----+---------+-------+
| ID      | int(11)       | NO   | PRI |         |       |
| NAME    | varchar(20)   | NO   |     |         |       |
| AGE     | int(11)       | NO   |     |         |       |
| ADDRESS | char(25)      | YES  |     | NULL    |       |
| SALARY  | decimal(18,2) | YES  |     | NULL    |       |
+---------+---------------+------+-----+---------+-------+
5 rows in set (0.00 sec)

Dies bedeutet, dass die Tabelle CUSTOMERS in der Datenbank verfügbar ist. Lassen Sie uns sie jetzt wie unten gezeigt löschen.

SQL> DROP TABLE CUSTOMERS;
Query OK, 0 rows affected (0.01 sec)

Wenn Sie nun den DESC-Befehl versuchen würden, wird der folgende Fehler angezeigt:

SQL> DESC CUSTOMERS;
ERROR 1146 (42S02): Table 'TEST.CUSTOMERS' doesn't exist

Hier ist TEST der Datenbankname, den wir für unsere Beispiele verwenden.

SQL - INSERT-Abfrage

Die SQL INSERT INTO Die Anweisung wird verwendet, um einer Tabelle in der Datenbank neue Datenzeilen hinzuzufügen.

Syntax

Es gibt zwei grundlegende Syntaxen der INSERT INTO-Anweisung, die unten gezeigt werden.

INSERT INTO TABLE_NAME (column1, column2, column3,...columnN)  
VALUES (value1, value2, value3,...valueN);

Hier sind Spalte1, Spalte2, Spalte3, ... SpalteN die Namen der Spalten in der Tabelle, in die Sie die Daten einfügen möchten.

Möglicherweise müssen Sie den Spaltennamen nicht in der SQL-Abfrage angeben, wenn Sie Werte für alle Spalten der Tabelle hinzufügen. Stellen Sie jedoch sicher, dass die Reihenfolge der Werte in derselben Reihenfolge wie die Spalten in der Tabelle liegt.

Das SQL INSERT INTO Die Syntax lautet wie folgt:

INSERT INTO TABLE_NAME VALUES (value1,value2,value3,...valueN);

Beispiel

Die folgenden Anweisungen würden sechs Datensätze in der Tabelle CUSTOMERS erstellen.

INSERT INTO CUSTOMERS (ID,NAME,AGE,ADDRESS,SALARY)
VALUES (1, 'Ramesh', 32, 'Ahmedabad', 2000.00 );

INSERT INTO CUSTOMERS (ID,NAME,AGE,ADDRESS,SALARY)
VALUES (2, 'Khilan', 25, 'Delhi', 1500.00 );

INSERT INTO CUSTOMERS (ID,NAME,AGE,ADDRESS,SALARY)
VALUES (3, 'kaushik', 23, 'Kota', 2000.00 );

INSERT INTO CUSTOMERS (ID,NAME,AGE,ADDRESS,SALARY)
VALUES (4, 'Chaitali', 25, 'Mumbai', 6500.00 );

INSERT INTO CUSTOMERS (ID,NAME,AGE,ADDRESS,SALARY)
VALUES (5, 'Hardik', 27, 'Bhopal', 8500.00 );

INSERT INTO CUSTOMERS (ID,NAME,AGE,ADDRESS,SALARY)
VALUES (6, 'Komal', 22, 'MP', 4500.00 );

Sie können einen Datensatz in der Tabelle CUSTOMERS erstellen, indem Sie die zweite Syntax wie unten gezeigt verwenden.

INSERT INTO CUSTOMERS 
VALUES (7, 'Muffy', 24, 'Indore', 10000.00 );

Alle obigen Anweisungen würden die folgenden Datensätze in der Tabelle CUSTOMERS erzeugen, wie unten gezeigt.

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Füllen Sie eine Tabelle mit einer anderen Tabelle

Sie können die Daten über die select-Anweisung über einer anderen Tabelle in eine Tabelle einfügen. vorausgesetzt, die andere Tabelle verfügt über eine Reihe von Feldern, die zum Auffüllen der ersten Tabelle erforderlich sind.

Hier ist die Syntax -

INSERT INTO first_table_name [(column1, column2, ... columnN)] 
   SELECT column1, column2, ...columnN 
   FROM second_table_name
   [WHERE condition];

SQL - SELECT-Abfrage

Die SQL SELECTDie Anweisung wird verwendet, um die Daten aus einer Datenbanktabelle abzurufen, die diese Daten in Form einer Ergebnistabelle zurückgibt. Diese Ergebnistabellen werden als Ergebnismengen bezeichnet.

Syntax

Die grundlegende Syntax der SELECT-Anweisung lautet wie folgt:

SELECT column1, column2, columnN FROM table_name;

Hier sind Spalte1, Spalte2 ... die Felder einer Tabelle, deren Werte Sie abrufen möchten. Wenn Sie alle im Feld verfügbaren Felder abrufen möchten, können Sie die folgende Syntax verwenden.

SELECT * FROM table_name;

Beispiel

Betrachten Sie die Tabelle CUSTOMERS mit den folgenden Datensätzen:

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Der folgende Code ist ein Beispiel, mit dem die Felder ID, Name und Gehalt der Kunden abgerufen werden, die in der Tabelle CUSTOMERS verfügbar sind.

SQL> SELECT ID, NAME, SALARY FROM CUSTOMERS;

Dies würde das folgende Ergebnis erzeugen -

+----+----------+----------+
| ID | NAME     | SALARY   |
+----+----------+----------+
|  1 | Ramesh   |  2000.00 |
|  2 | Khilan   |  1500.00 |
|  3 | kaushik  |  2000.00 |
|  4 | Chaitali |  6500.00 |
|  5 | Hardik   |  8500.00 |
|  6 | Komal    |  4500.00 |
|  7 | Muffy    | 10000.00 |
+----+----------+----------+

Wenn Sie alle Felder der Tabelle CUSTOMERS abrufen möchten, sollten Sie die folgende Abfrage verwenden.

SQL> SELECT * FROM CUSTOMERS;

Dies würde das Ergebnis wie unten gezeigt erzeugen.

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

SQL - WHERE-Klausel

Die SQL WHEREDie Klausel wird verwendet, um eine Bedingung anzugeben, während die Daten aus einer einzelnen Tabelle abgerufen oder mit mehreren Tabellen verknüpft werden. Wenn die angegebene Bedingung erfüllt ist, gibt nur sie einen bestimmten Wert aus der Tabelle zurück. Sie sollten die WHERE-Klausel verwenden, um die Datensätze zu filtern und nur die erforderlichen Datensätze abzurufen.

Die WHERE-Klausel wird nicht nur in der SELECT-Anweisung verwendet, sondern auch in der UPDATE-, DELETE-Anweisung usw., die wir in den folgenden Kapiteln untersuchen würden.

Syntax

Die grundlegende Syntax der SELECT-Anweisung mit der WHERE-Klausel lautet wie folgt.

SELECT column1, column2, columnN 
FROM table_name
WHERE [condition]

Sie können eine Bedingung mithilfe der Vergleichs- oder logischen Operatoren wie>, <, =, angeben.LIKE, NOTusw. Die folgenden Beispiele würden dieses Konzept verdeutlichen.

Beispiel

Betrachten Sie die Tabelle CUSTOMERS mit den folgenden Datensätzen:

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Der folgende Code ist ein Beispiel, mit dem die Felder ID, Name und Gehalt aus der Tabelle CUSTOMERS abgerufen werden, in der das Gehalt größer als 2000 ist.

SQL> SELECT ID, NAME, SALARY 
FROM CUSTOMERS
WHERE SALARY > 2000;

Dies würde das folgende Ergebnis erzeugen -

+----+----------+----------+
| ID | NAME     | SALARY   |
+----+----------+----------+
|  4 | Chaitali |  6500.00 |
|  5 | Hardik   |  8500.00 |
|  6 | Komal    |  4500.00 |
|  7 | Muffy    | 10000.00 |
+----+----------+----------+

Die folgende Abfrage ist ein Beispiel, bei dem die Felder ID, Name und Gehalt aus der Tabelle CUSTOMERS für einen Kunden mit dem Namen abgerufen werden Hardik.

Hierbei ist zu beachten, dass alle Zeichenfolgen in einfachen Anführungszeichen ('') angegeben werden sollten. Numerische Werte sollten wie im obigen Beispiel ohne Anführungszeichen angegeben werden.

SQL> SELECT ID, NAME, SALARY 
FROM CUSTOMERS
WHERE NAME = 'Hardik';

Dies würde das folgende Ergebnis erzeugen -

+----+----------+----------+
| ID | NAME     | SALARY   |
+----+----------+----------+
|  5 | Hardik   |  8500.00 |
+----+----------+----------+

SQL - AND und OR Conjunctive Operators

Die SQL AND & OROperatoren werden verwendet, um mehrere Bedingungen zu kombinieren, um Daten in einer SQL-Anweisung einzugrenzen. Diese beiden Operatoren werden als Konjunktivoperatoren bezeichnet.

Diese Operatoren bieten die Möglichkeit, mehrere Vergleiche mit verschiedenen Operatoren in derselben SQL-Anweisung durchzuführen.

Der AND-Operator

Das AND Der Operator ermöglicht das Vorhandensein mehrerer Bedingungen in der WHERE-Klausel einer SQL-Anweisung.

Syntax

Die grundlegende Syntax des AND-Operators mit einer WHERE-Klausel lautet wie folgt:

SELECT column1, column2, columnN 
FROM table_name
WHERE [condition1] AND [condition2]...AND [conditionN];

Sie können N Bedingungen mit dem AND-Operator kombinieren. Damit eine Aktion von der SQL-Anweisung ausgeführt werden kann, sei es eine Transaktion oder eine Abfrage, müssen alle durch das UND getrennten Bedingungen TRUE sein.

Beispiel

Betrachten Sie die Tabelle CUSTOMERS mit den folgenden Datensätzen:

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Im Folgenden finden Sie ein Beispiel, in dem die Felder ID, Name und Gehalt aus der Tabelle CUSTOMERS abgerufen werden, in der das Gehalt größer als 2000 und das Alter weniger als 25 Jahre beträgt.

SQL> SELECT ID, NAME, SALARY 
FROM CUSTOMERS
WHERE SALARY > 2000 AND age < 25;

Dies würde das folgende Ergebnis erzeugen -

+----+-------+----------+
| ID | NAME  | SALARY   |
+----+-------+----------+
|  6 | Komal |  4500.00 |
|  7 | Muffy | 10000.00 |
+----+-------+----------+

Der OP-Operator

Der OR-Operator wird verwendet, um mehrere Bedingungen in der WHERE-Klausel einer SQL-Anweisung zu kombinieren.

Syntax

Die grundlegende Syntax des OR-Operators mit einer WHERE-Klausel lautet wie folgt:

SELECT column1, column2, columnN 
FROM table_name
WHERE [condition1] OR [condition2]...OR [conditionN]

Sie können N Bedingungen mit dem Operator OR kombinieren. Damit eine Aktion von der SQL-Anweisung ausgeführt werden kann, unabhängig davon, ob es sich um eine Transaktion oder eine Abfrage handelt, muss nur eine der durch das ODER getrennten Bedingungen TRUE sein.

Beispiel

Betrachten Sie die Tabelle CUSTOMERS mit den folgenden Datensätzen:

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Der folgende Codeblock enthält eine Abfrage, mit der die Felder ID, Name und Gehalt aus der Tabelle CUSTOMERS abgerufen werden, in der das Gehalt größer als 2000 oder das Alter kleiner als 25 Jahre ist.

SQL> SELECT ID, NAME, SALARY 
FROM CUSTOMERS
WHERE SALARY > 2000 OR age < 25;

Dies würde das folgende Ergebnis erzeugen -

+----+----------+----------+
| ID | NAME     | SALARY   |
+----+----------+----------+
|  3 | kaushik  |  2000.00 |
|  4 | Chaitali |  6500.00 |
|  5 | Hardik   |  8500.00 |
|  6 | Komal    |  4500.00 |
|  7 | Muffy    | 10000.00 |
+----+----------+----------+

SQL - UPDATE Abfrage

Die SQL UPDATEDie Abfrage wird verwendet, um die vorhandenen Datensätze in einer Tabelle zu ändern. Sie können die WHERE-Klausel mit der UPDATE-Abfrage verwenden, um die ausgewählten Zeilen zu aktualisieren, da sonst alle Zeilen betroffen wären.

Syntax

Die grundlegende Syntax der UPDATE-Abfrage mit einer WHERE-Klausel lautet wie folgt:

UPDATE table_name
SET column1 = value1, column2 = value2...., columnN = valueN
WHERE [condition];

Sie können N Bedingungen mit den Operatoren AND oder OR kombinieren.

Beispiel

Betrachten Sie die Tabelle CUSTOMERS mit den folgenden Datensätzen:

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Die folgende Abfrage aktualisiert die ADRESSE für einen Kunden, dessen ID-Nummer 6 in der Tabelle ist.

SQL> UPDATE CUSTOMERS
SET ADDRESS = 'Pune'
WHERE ID = 6;

Die Tabelle CUSTOMERS würde nun die folgenden Datensätze enthalten:

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | Pune      |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Wenn Sie alle Spaltenwerte ADDRESS und SALARY in der Tabelle CUSTOMERS ändern möchten, müssen Sie die WHERE-Klausel nicht verwenden, da die UPDATE-Abfrage ausreichen würde, wie im folgenden Codeblock gezeigt.

SQL> UPDATE CUSTOMERS
SET ADDRESS = 'Pune', SALARY = 1000.00;

Die Tabelle CUSTOMERS würde nun die folgenden Datensätze enthalten:

+----+----------+-----+---------+---------+
| ID | NAME     | AGE | ADDRESS | SALARY  |
+----+----------+-----+---------+---------+
|  1 | Ramesh   |  32 | Pune    | 1000.00 |
|  2 | Khilan   |  25 | Pune    | 1000.00 |
|  3 | kaushik  |  23 | Pune    | 1000.00 |
|  4 | Chaitali |  25 | Pune    | 1000.00 |
|  5 | Hardik   |  27 | Pune    | 1000.00 |
|  6 | Komal    |  22 | Pune    | 1000.00 |
|  7 | Muffy    |  24 | Pune    | 1000.00 |
+----+----------+-----+---------+---------+

SQL - DELETE-Abfrage

Die SQL DELETE-Abfrage wird verwendet, um die vorhandenen Datensätze aus einer Tabelle zu löschen.

Sie können die WHERE-Klausel mit einer DELETE-Abfrage verwenden, um die ausgewählten Zeilen zu löschen, da sonst alle Datensätze gelöscht würden.

Syntax

Die grundlegende Syntax der DELETE-Abfrage mit der WHERE-Klausel lautet wie folgt:

DELETE FROM table_name
WHERE [condition];

Sie können N Bedingungen mit UND- oder ODER-Operatoren kombinieren.

Beispiel

Betrachten Sie die Tabelle CUSTOMERS mit den folgenden Datensätzen:

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Der folgende Code enthält eine Abfrage, die einen Kunden mit der ID 6 löscht.

SQL> DELETE FROM CUSTOMERS
WHERE ID = 6;

Jetzt würde die Tabelle CUSTOMERS die folgenden Datensätze enthalten.

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Wenn Sie alle Datensätze aus der Tabelle CUSTOMERS LÖSCHEN möchten, müssen Sie die WHERE-Klausel nicht verwenden, und die DELETE-Abfrage lautet wie folgt:

SQL> DELETE FROM CUSTOMERS;

Jetzt hätte die Tabelle CUSTOMERS keine Aufzeichnung mehr.

SQL - LIKE - Klausel

Die SQL LIKEKlausel wird verwendet, um einen Wert mit Platzhalteroperatoren mit ähnlichen Werten zu vergleichen. In Verbindung mit dem Operator LIKE werden zwei Platzhalter verwendet.

• Das Prozentzeichen (%)
• Der Unterstrich (_)

Das Prozentzeichen steht für null, ein oder mehrere Zeichen. Der Unterstrich steht für eine einzelne Zahl oder ein einzelnes Zeichen. Diese Symbole können in Kombinationen verwendet werden.

Syntax

Die grundlegende Syntax von% und _ lautet wie folgt:

SELECT FROM table_name
WHERE column LIKE 'XXXX%'

or 

SELECT FROM table_name
WHERE column LIKE '%XXXX%'

or

SELECT FROM table_name
WHERE column LIKE 'XXXX_'

or

SELECT FROM table_name
WHERE column LIKE '_XXXX'

or

SELECT FROM table_name
WHERE column LIKE '_XXXX_'

Sie können N Bedingungen mit UND- oder ODER-Operatoren kombinieren. Hier kann XXXX ein beliebiger numerischer Wert oder ein Zeichenfolgenwert sein.

Beispiel

Die folgende Tabelle enthält einige Beispiele, die zeigen, dass der WHERE-Teil eine andere LIKE-Klausel mit den Operatoren '%' und '_' hat.

Sr.Nr.	Aussage & Beschreibung
1	WHERE SALARY LIKE '200%' Findet alle Werte, die mit 200 beginnen.
2	WHERE SALARY LIKE '%200%' Findet alle Werte mit 200 an einer beliebigen Position.
3	WHERE SALARY LIKE '_00%' Findet alle Werte mit 00 an der zweiten und dritten Position.
4	WHERE SALARY LIKE '2_%_%' Findet alle Werte, die mit 2 beginnen und mindestens 3 Zeichen lang sind.
5	WHERE SALARY LIKE '%2' Findet alle Werte, die mit 2 enden.
6	WHERE SALARY LIKE '_2%3' Findet alle Werte, die eine 2 an zweiter Stelle haben und mit einer 3 enden.
7	WHERE SALARY LIKE '2___3' Findet alle Werte in einer fünfstelligen Zahl, die mit 2 beginnen und mit 3 enden.

Nehmen wir ein reales Beispiel, betrachten wir die CUSTOMERS-Tabelle mit den unten gezeigten Datensätzen.

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Es folgt ein Beispiel, in dem alle Datensätze aus der Tabelle CUSTOMERS angezeigt werden, in der das Gehalt mit 200 beginnt.

SQL> SELECT * FROM CUSTOMERS
WHERE SALARY LIKE '200%';

Dies würde das folgende Ergebnis erzeugen -

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
+----+----------+-----+-----------+----------+

SQL - TOP-, LIMIT- oder ROWNUM-Klausel

Die SQL TOP Klausel wird verwendet, um eine TOP N-Zahl oder X-Prozent-Datensätze aus einer Tabelle abzurufen.

Note- Alle Datenbanken unterstützen die TOP-Klausel nicht. Zum Beispiel unterstützt MySQL dasLIMIT Klausel zum Abrufen einer begrenzten Anzahl von Datensätzen, während Oracle die verwendet ROWNUM Befehl zum Abrufen einer begrenzten Anzahl von Datensätzen.

Syntax

Die grundlegende Syntax der TOP-Klausel mit einer SELECT-Anweisung lautet wie folgt.

SELECT TOP number|percent column_name(s)
FROM table_name
WHERE [condition]

Beispiel

Betrachten Sie die Tabelle CUSTOMERS mit den folgenden Datensätzen:

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Die folgende Abfrage ist ein Beispiel auf dem SQL Server, mit dem die drei wichtigsten Datensätze aus der Tabelle CUSTOMERS abgerufen werden.

SQL> SELECT TOP 3 * FROM CUSTOMERS;

Dies würde das folgende Ergebnis erzeugen -

+----+---------+-----+-----------+---------+
| ID | NAME    | AGE | ADDRESS   | SALARY  |
+----+---------+-----+-----------+---------+
|  1 | Ramesh  |  32 | Ahmedabad | 2000.00 |
|  2 | Khilan  |  25 | Delhi     | 1500.00 |
|  3 | kaushik |  23 | Kota      | 2000.00 |
+----+---------+-----+-----------+---------+

Wenn Sie einen MySQL-Server verwenden, finden Sie hier ein gleichwertiges Beispiel:

SQL> SELECT * FROM CUSTOMERS
LIMIT 3;

Dies würde das folgende Ergebnis erzeugen -

+----+---------+-----+-----------+---------+
| ID | NAME    | AGE | ADDRESS   | SALARY  |
+----+---------+-----+-----------+---------+
|  1 | Ramesh  |  32 | Ahmedabad | 2000.00 |
|  2 | Khilan  |  25 | Delhi     | 1500.00 |
|  3 | kaushik |  23 | Kota      | 2000.00 |
+----+---------+-----+-----------+---------+

Wenn Sie einen Oracle-Server verwenden, enthält der folgende Codeblock ein gleichwertiges Beispiel.

SQL> SELECT * FROM CUSTOMERS
WHERE ROWNUM <= 3;

Dies würde das folgende Ergebnis erzeugen -

+----+---------+-----+-----------+---------+
| ID | NAME    | AGE | ADDRESS   | SALARY  |
+----+---------+-----+-----------+---------+
|  1 | Ramesh  |  32 | Ahmedabad | 2000.00 |
|  2 | Khilan  |  25 | Delhi     | 1500.00 |
|  3 | kaushik |  23 | Kota      | 2000.00 |
+----+---------+-----+-----------+---------+

SQL - ORDER BY-Klausel

Die SQL ORDER BYKlausel wird verwendet, um die Daten in aufsteigender oder absteigender Reihenfolge basierend auf einer oder mehreren Spalten zu sortieren. Einige Datenbanken sortieren die Abfrageergebnisse standardmäßig in aufsteigender Reihenfolge.

Syntax

Die grundlegende Syntax der ORDER BY-Klausel lautet wie folgt:

SELECT column-list 
FROM table_name 
[WHERE condition] 
[ORDER BY column1, column2, .. columnN] [ASC | DESC];

Sie können mehr als eine Spalte in der ORDER BY-Klausel verwenden. Stellen Sie sicher, dass die Spalte, die Sie zum Sortieren dieser Spalte verwenden, in der Spaltenliste enthalten sein soll.

Beispiel

Betrachten Sie die Tabelle CUSTOMERS mit den folgenden Datensätzen:

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Der folgende Codeblock enthält ein Beispiel, das das Ergebnis in aufsteigender Reihenfolge nach NAME und SALARY sortiert.

SQL> SELECT * FROM CUSTOMERS
   ORDER BY NAME, SALARY;

Dies würde das folgende Ergebnis erzeugen -

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
+----+----------+-----+-----------+----------+

Der folgende Codeblock enthält ein Beispiel, mit dem das Ergebnis in absteigender Reihenfolge nach NAME sortiert wird.

SQL> SELECT * FROM CUSTOMERS
   ORDER BY NAME DESC;

Dies würde das folgende Ergebnis erzeugen -

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
+----+----------+-----+-----------+----------+

SQL - Gruppieren nach

Die SQL GROUP BYDie Klausel wird in Zusammenarbeit mit der SELECT-Anweisung verwendet, um identische Daten in Gruppen anzuordnen. Diese GROUP BY-Klausel folgt der WHERE-Klausel in einer SELECT-Anweisung und steht vor der ORDER BY-Klausel.

Syntax

Die grundlegende Syntax einer GROUP BY-Klausel wird im folgenden Codeblock gezeigt. Die GROUP BY-Klausel muss den Bedingungen in der WHERE-Klausel entsprechen und der ORDER BY-Klausel vorangehen, falls eine verwendet wird.

SELECT column1, column2
FROM table_name
WHERE [ conditions ]
GROUP BY column1, column2
ORDER BY column1, column2

Beispiel

Angenommen, die Tabelle CUSTOMERS enthält die folgenden Datensätze:

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Wenn Sie den Gesamtbetrag des Gehalts für jeden Kunden wissen möchten, lautet die GROUP BY-Abfrage wie folgt.

SQL> SELECT NAME, SUM(SALARY) FROM CUSTOMERS
   GROUP BY NAME;

Dies würde das folgende Ergebnis erzeugen -

+----------+-------------+
| NAME     | SUM(SALARY) |
+----------+-------------+
| Chaitali |     6500.00 |
| Hardik   |     8500.00 |
| kaushik  |     2000.00 |
| Khilan   |     1500.00 |
| Komal    |     4500.00 |
| Muffy    |    10000.00 |
| Ramesh   |     2000.00 |
+----------+-------------+

Betrachten wir nun eine Tabelle, in der die Tabelle CUSTOMERS die folgenden Datensätze mit doppelten Namen enthält:

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Ramesh   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | kaushik  |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Wenn Sie nun den Gesamtlohn für jeden Kunden wissen möchten, lautet die GROUP BY-Abfrage wie folgt:

SQL> SELECT NAME, SUM(SALARY) FROM CUSTOMERS
   GROUP BY NAME;

Dies würde das folgende Ergebnis erzeugen -

+---------+-------------+
| NAME    | SUM(SALARY) |
+---------+-------------+
| Hardik  |     8500.00 |
| kaushik |     8500.00 |
| Komal   |     4500.00 |
| Muffy   |    10000.00 |
| Ramesh  |     3500.00 |
+---------+-------------+

SQL - Distinct Keyword

Die SQL DISTINCT Das Schlüsselwort wird in Verbindung mit der SELECT-Anweisung verwendet, um alle doppelten Datensätze zu entfernen und nur eindeutige Datensätze abzurufen.

Es kann vorkommen, dass eine Tabelle mehrere doppelte Datensätze enthält. Beim Abrufen solcher Datensätze ist es sinnvoller, nur diese eindeutigen Datensätze abzurufen, anstatt doppelte Datensätze abzurufen.

Syntax

Die grundlegende Syntax des Schlüsselworts DISTINCT zum Entfernen der doppelten Datensätze lautet wie folgt:

SELECT DISTINCT column1, column2,.....columnN 
FROM table_name
WHERE [condition]

Beispiel

Betrachten Sie die Tabelle CUSTOMERS mit den folgenden Datensätzen:

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Lassen Sie uns zunächst sehen, wie die folgende SELECT-Abfrage die doppelten Gehaltsdatensätze zurückgibt.

SQL> SELECT SALARY FROM CUSTOMERS
   ORDER BY SALARY;

Dies würde das folgende Ergebnis ergeben, bei dem das Gehalt (2000) zweimal kommt, was ein doppelter Datensatz aus der ursprünglichen Tabelle ist.

+----------+
| SALARY   |
+----------+
|  1500.00 |
|  2000.00 |
|  2000.00 |
|  4500.00 |
|  6500.00 |
|  8500.00 |
| 10000.00 |
+----------+

Verwenden wir nun das Schlüsselwort DISTINCT mit der obigen SELECT-Abfrage und sehen dann das Ergebnis.

SQL> SELECT DISTINCT SALARY FROM CUSTOMERS
   ORDER BY SALARY;

Dies würde das folgende Ergebnis ergeben, wenn wir keinen doppelten Eintrag haben.

+----------+
| SALARY   |
+----------+
|  1500.00 |
|  2000.00 |
|  4500.00 |
|  6500.00 |
|  8500.00 |
| 10000.00 |
+----------+

SQL - SORTIEREN von Ergebnissen

Die SQL ORDER BYKlausel wird verwendet, um die Daten in aufsteigender oder absteigender Reihenfolge basierend auf einer oder mehreren Spalten zu sortieren. Einige Datenbanken sortieren die Abfrageergebnisse standardmäßig in aufsteigender Reihenfolge.

Syntax

Die grundlegende Syntax der ORDER BY-Klausel, mit der das Ergebnis in aufsteigender oder absteigender Reihenfolge sortiert wird, lautet wie folgt:

SELECT column-list 
FROM table_name 
[WHERE condition] 
[ORDER BY column1, column2, .. columnN] [ASC | DESC];

Sie können mehr als eine Spalte in der ORDER BY-Klausel verwenden. Stellen Sie sicher, dass sich jede Spalte, die Sie zum Sortieren verwenden, in der Spaltenliste befindet.

Beispiel

Betrachten Sie die Tabelle CUSTOMERS mit den folgenden Datensätzen:

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Das folgende Beispiel zeigt das Ergebnis in aufsteigender Reihenfolge nach NAME und SALARY.

SQL> SELECT * FROM CUSTOMERS
   ORDER BY NAME, SALARY;

Dies würde das folgende Ergebnis erzeugen -

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
+----+----------+-----+-----------+----------+

Der folgende Codeblock enthält ein Beispiel, das das Ergebnis in absteigender Reihenfolge nach NAME sortiert.

SQL> SELECT * FROM CUSTOMERS
   ORDER BY NAME DESC;

Dies würde das folgende Ergebnis erzeugen -

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
+----+----------+-----+-----------+----------+

Um die Zeilen mit ihrer eigenen bevorzugten Reihenfolge abzurufen, wird folgende SELECT-Abfrage verwendet:

SQL> SELECT * FROM CUSTOMERS
   ORDER BY (CASE ADDRESS
   WHEN 'DELHI' 	 THEN 1
   WHEN 'BHOPAL' 	 THEN 2
   WHEN 'KOTA' 	 THEN 3
   WHEN 'AHMEDABAD' THEN 4
   WHEN 'MP' 	THEN 5
   ELSE 100 END) ASC, ADDRESS DESC;

Dies würde das folgende Ergebnis erzeugen -

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
+----+----------+-----+-----------+----------+

Dadurch werden die Kunden nach ADRESSE in Ihrem sortiert ownoOrderbevorzugt zuerst und in einer natürlichen Reihenfolge für die verbleibenden Adressen. Außerdem werden die verbleibenden Adressen in umgekehrter alphabetischer Reihenfolge sortiert.

SQL - Einschränkungen

Einschränkungen sind die Regeln, die für die Datenspalten einer Tabelle gelten. Diese werden verwendet, um den Datentyp zu begrenzen, der in eine Tabelle aufgenommen werden kann. Dies stellt die Genauigkeit und Zuverlässigkeit der Daten in der Datenbank sicher.

Einschränkungen können entweder auf Spalten- oder auf Tabellenebene liegen. Die Einschränkungen auf Spaltenebene werden nur auf eine Spalte angewendet, während die Einschränkungen auf Tabellenebene auf die gesamte Tabelle angewendet werden.

Im Folgenden sind einige der am häufigsten verwendeten Einschränkungen aufgeführt, die in SQL verfügbar sind. Diese Einschränkungen wurden bereits im Kapitel SQL - RDBMS-Konzepte erläutert. Es lohnt sich jedoch, sie an dieser Stelle zu überarbeiten.

• NOT NULL-Einschränkung - Stellt sicher, dass eine Spalte keinen NULL-Wert haben kann.

• DEFAULT Constraint - Stellt einen Standardwert für eine Spalte bereit, wenn keiner angegeben ist.

• EINZIGARTIGE Einschränkung - Stellt sicher, dass alle Werte in einer Spalte unterschiedlich sind.

• PRIMARY-Schlüssel - Identifiziert jede Zeile / jeden Datensatz in einer Datenbanktabelle eindeutig.

• AUSLÄNDISCHER Schlüssel - Identifiziert eine Zeile / einen Datensatz in einer der angegebenen Datenbanktabellen eindeutig.

• CHECK-Einschränkung - Die CHECK-Einschränkung stellt sicher, dass alle Werte in einer Spalte bestimmte Bedingungen erfüllen.

• INDEX - Wird verwendet, um Daten sehr schnell zu erstellen und aus der Datenbank abzurufen.

Einschränkungen können angegeben werden, wenn eine Tabelle mit der Anweisung CREATE TABLE erstellt wird, oder Sie können die Anweisung ALTER TABLE verwenden, um Einschränkungen auch nach dem Erstellen der Tabelle zu erstellen.

Einschränkungen fallen lassen

Jede von Ihnen definierte Einschränkung kann mit dem Befehl ALTER TABLE mit der Option DROP CONSTRAINT gelöscht werden.

Um beispielsweise die Primärschlüsseleinschränkung in der Tabelle EMPLOYEES zu löschen, können Sie den folgenden Befehl verwenden.

ALTER TABLE EMPLOYEES DROP CONSTRAINT EMPLOYEES_PK;

Einige Implementierungen bieten möglicherweise Verknüpfungen zum Löschen bestimmter Einschränkungen. Um beispielsweise die Primärschlüsseleinschränkung für eine Tabelle in Oracle zu löschen, können Sie den folgenden Befehl verwenden.

ALTER TABLE EMPLOYEES DROP PRIMARY KEY;

Bei einigen Implementierungen können Sie Einschränkungen deaktivieren. Anstatt eine Einschränkung dauerhaft aus der Datenbank zu löschen, möchten Sie die Einschränkung möglicherweise vorübergehend deaktivieren und später aktivieren.

Integritätsbedingungen

Integritätsbeschränkungen werden verwendet, um die Genauigkeit und Konsistenz der Daten in einer relationalen Datenbank sicherzustellen. Die Datenintegrität wird in einer relationalen Datenbank durch das Konzept der referenziellen Integrität behandelt.

Es gibt viele Arten von Integritätsbeschränkungen, die eine Rolle spielen Referential Integrity (RI). Diese Einschränkungen umfassen Primärschlüssel, Fremdschlüssel, eindeutige Einschränkungen und andere Einschränkungen, die oben erwähnt wurden.

SQL - Verwenden von Joins

Die SQL JoinsKlausel wird verwendet, um Datensätze aus zwei oder mehr Tabellen in einer Datenbank zu kombinieren. Ein JOIN ist ein Mittel zum Kombinieren von Feldern aus zwei Tabellen unter Verwendung gemeinsamer Werte.

Betrachten Sie die folgenden zwei Tabellen -

Table 1 - KUNDENTabelle

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Table 2 - BESTELLTabelle

+-----+---------------------+-------------+--------+
|OID  | DATE                | CUSTOMER_ID | AMOUNT |
+-----+---------------------+-------------+--------+
| 102 | 2009-10-08 00:00:00 |           3 |   3000 |
| 100 | 2009-10-08 00:00:00 |           3 |   1500 |
| 101 | 2009-11-20 00:00:00 |           2 |   1560 |
| 103 | 2008-05-20 00:00:00 |           4 |   2060 |
+-----+---------------------+-------------+--------+

Lassen Sie uns nun diese beiden Tabellen in unserer SELECT-Anweisung wie unten gezeigt verbinden.

SQL> SELECT ID, NAME, AGE, AMOUNT
   FROM CUSTOMERS, ORDERS
   WHERE  CUSTOMERS.ID = ORDERS.CUSTOMER_ID;

Dies würde das folgende Ergebnis erzeugen.

+----+----------+-----+--------+
| ID | NAME     | AGE | AMOUNT |
+----+----------+-----+--------+
|  3 | kaushik  |  23 |   3000 |
|  3 | kaushik  |  23 |   1500 |
|  2 | Khilan   |  25 |   1560 |
|  4 | Chaitali |  25 |   2060 |
+----+----------+-----+--------+

Hier fällt auf, dass der Join in der WHERE-Klausel ausgeführt wird. Zum Verknüpfen von Tabellen können mehrere Operatoren verwendet werden, z. B. =, <,>, <>, <=,> = ,! =, ZWISCHEN, WIE und NICHT. Sie können alle zum Verknüpfen von Tabellen verwendet werden. Der häufigste Operator ist jedoch das Gleichheitszeichen.

In SQL stehen verschiedene Arten von Joins zur Verfügung:

• INNER JOIN - Gibt Zeilen zurück, wenn in beiden Tabellen eine Übereinstimmung vorliegt .

• LEFT JOIN - Gibt alle Zeilen aus der linken Tabelle zurück, auch wenn die rechte Tabelle keine Übereinstimmungen enthält.

• RIGHT JOIN - Gibt alle Zeilen aus der rechten Tabelle zurück, auch wenn die linke Tabelle keine Übereinstimmungen enthält.

• FULL JOIN - Gibt Zeilen zurück, wenn in einer der Tabellen eine Übereinstimmung vorliegt.

• SELF JOIN - wird verwendet, um eine Tabelle mit sich selbst zu verbinden, als wäre die Tabelle zwei Tabellen, wobei mindestens eine Tabelle in der SQL-Anweisung vorübergehend umbenannt wird.

• CARTESIAN JOIN - Gibt das kartesische Produkt der Datensätze aus den zwei oder mehr verknüpften Tabellen zurück.

Lassen Sie uns nun jeden dieser Joins im Detail besprechen.

SQL - UNIONS CLAUSE

Die SQL UNION-Klausel / der SQL UNION-Operator wird verwendet, um die Ergebnisse von zwei oder mehr SELECT-Anweisungen zu kombinieren, ohne doppelte Zeilen zurückzugeben.

Um diese UNION-Klausel verwenden zu können, muss jede SELECT-Anweisung haben

• Die gleiche Anzahl von Spalten ausgewählt
• Die gleiche Anzahl von Spaltenausdrücken
• Der gleiche Datentyp und
• Haben Sie sie in der gleichen Reihenfolge

Sie müssen aber nicht gleich lang sein.

Syntax

Die grundlegende Syntax von a UNION Klausel ist wie folgt -

SELECT column1 [, column2 ]
FROM table1 [, table2 ]
[WHERE condition]

UNION

SELECT column1 [, column2 ]
FROM table1 [, table2 ]
[WHERE condition]

Hier kann die angegebene Bedingung ein beliebiger Ausdruck sein, der auf Ihrer Anforderung basiert.

Beispiel

Betrachten Sie die folgenden zwei Tabellen.

Table 1 - KUNDENTabelle ist wie folgt.

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Table 2 - BESTELLUNGEN Die Tabelle lautet wie folgt.

+-----+---------------------+-------------+--------+
|OID  | DATE                | CUSTOMER_ID | AMOUNT |
+-----+---------------------+-------------+--------+
| 102 | 2009-10-08 00:00:00 |           3 |   3000 |
| 100 | 2009-10-08 00:00:00 |           3 |   1500 |
| 101 | 2009-11-20 00:00:00 |           2 |   1560 |
| 103 | 2008-05-20 00:00:00 |           4 |   2060 |
+-----+---------------------+-------------+--------+

Lassen Sie uns nun diese beiden Tabellen in unserer SELECT-Anweisung wie folgt verbinden:

SQL> SELECT  ID, NAME, AMOUNT, DATE
   FROM CUSTOMERS
   LEFT JOIN ORDERS
   ON CUSTOMERS.ID = ORDERS.CUSTOMER_ID
UNION
   SELECT  ID, NAME, AMOUNT, DATE
   FROM CUSTOMERS
   RIGHT JOIN ORDERS
   ON CUSTOMERS.ID = ORDERS.CUSTOMER_ID;

Dies würde das folgende Ergebnis erzeugen -

+------+----------+--------+---------------------+
| ID   | NAME     | AMOUNT | DATE                |
+------+----------+--------+---------------------+
|    1 | Ramesh   |   NULL | NULL                |
|    2 | Khilan   |   1560 | 2009-11-20 00:00:00 |
|    3 | kaushik  |   3000 | 2009-10-08 00:00:00 |
|    3 | kaushik  |   1500 | 2009-10-08 00:00:00 |
|    4 | Chaitali |   2060 | 2008-05-20 00:00:00 |
|    5 | Hardik   |   NULL | NULL                |
|    6 | Komal    |   NULL | NULL                |
|    7 | Muffy    |   NULL | NULL                |
+------+----------+--------+---------------------+

Die UNION ALL-Klausel

Der Operator UNION ALL wird verwendet, um die Ergebnisse von zwei SELECT-Anweisungen einschließlich doppelter Zeilen zu kombinieren.

Die gleichen Regeln, die für die UNION-Klausel gelten, gelten auch für den UNION ALL-Operator.

Syntax

Die grundlegende Syntax der UNION ALL ist wie folgt.

SELECT column1 [, column2 ]
FROM table1 [, table2 ]
[WHERE condition]

UNION ALL

SELECT column1 [, column2 ]
FROM table1 [, table2 ]
[WHERE condition]

Hier kann die angegebene Bedingung ein beliebiger Ausdruck sein, der auf Ihrer Anforderung basiert.

Beispiel

Betrachten Sie die folgenden zwei Tabellen:

Table 1 - KUNDENTabelle ist wie folgt.

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Table 2 - Die Tabelle ORDERS lautet wie folgt.

+-----+---------------------+-------------+--------+
|OID  | DATE                | CUSTOMER_ID | AMOUNT |
+-----+---------------------+-------------+--------+
| 102 | 2009-10-08 00:00:00 |           3 |   3000 |
| 100 | 2009-10-08 00:00:00 |           3 |   1500 |
| 101 | 2009-11-20 00:00:00 |           2 |   1560 |
| 103 | 2008-05-20 00:00:00 |           4 |   2060 |
+-----+---------------------+-------------+--------+

Lassen Sie uns nun diese beiden Tabellen in unserer SELECT-Anweisung wie folgt verbinden:

SQL> SELECT  ID, NAME, AMOUNT, DATE
   FROM CUSTOMERS
   LEFT JOIN ORDERS
   ON CUSTOMERS.ID = ORDERS.CUSTOMER_ID
UNION ALL
   SELECT  ID, NAME, AMOUNT, DATE
   FROM CUSTOMERS
   RIGHT JOIN ORDERS
   ON CUSTOMERS.ID = ORDERS.CUSTOMER_ID;

Dies würde das folgende Ergebnis erzeugen -

+------+----------+--------+---------------------+
| ID   | NAME     | AMOUNT | DATE                |
+------+----------+--------+---------------------+
|    1 | Ramesh   |   NULL | NULL                |
|    2 | Khilan   |   1560 | 2009-11-20 00:00:00 |
|    3 | kaushik  |   3000 | 2009-10-08 00:00:00 |
|    3 | kaushik  |   1500 | 2009-10-08 00:00:00 |
|    4 | Chaitali |   2060 | 2008-05-20 00:00:00 |
|    5 | Hardik   |   NULL | NULL                |
|    6 | Komal    |   NULL | NULL                |
|    7 | Muffy    |   NULL | NULL                |
|    3 | kaushik  |   3000 | 2009-10-08 00:00:00 |
|    3 | kaushik  |   1500 | 2009-10-08 00:00:00 |
|    2 | Khilan   |   1560 | 2009-11-20 00:00:00 |
|    4 | Chaitali |   2060 | 2008-05-20 00:00:00 |
+------+----------+--------+---------------------+

Es gibt zwei weitere Klauseln (dh Operatoren), die der UNION-Klausel ähneln.

• SQL INTERSECT-Klausel - Hiermit werden zwei SELECT-Anweisungen kombiniert, es werden jedoch nur Zeilen aus der ersten SELECT-Anweisung zurückgegeben, die mit einer Zeile in der zweiten SELECT-Anweisung identisch sind.

• SQL EXCEPT-Klausel - Diese Kombination kombiniert zwei SELECT-Anweisungen und gibt Zeilen aus der ersten SELECT-Anweisung zurück, die von der zweiten SELECT-Anweisung nicht zurückgegeben werden.

SQL - NULL-Werte

Die SQL NULList der Begriff, der verwendet wird, um einen fehlenden Wert darzustellen. Ein NULL-Wert in einer Tabelle ist ein Wert in einem Feld, der leer zu sein scheint.

Ein Feld mit einem NULL-Wert ist ein Feld ohne Wert. Es ist sehr wichtig zu verstehen, dass sich ein NULL-Wert von einem Nullwert oder einem Feld mit Leerzeichen unterscheidet.

Syntax

Die grundlegende Syntax von NULL beim Erstellen einer Tabelle.

SQL> CREATE TABLE CUSTOMERS(
   ID   INT              NOT NULL,
   NAME VARCHAR (20)     NOT NULL,
   AGE  INT              NOT NULL,
   ADDRESS  CHAR (25) ,
   SALARY   DECIMAL (18, 2),       
   PRIMARY KEY (ID)
);

Hier, NOT NULLbedeutet, dass die Spalte immer einen expliziten Wert des angegebenen Datentyps akzeptieren sollte. Es gibt zwei Spalten, in denen wir NICHT NULL verwendet haben, was bedeutet, dass diese Spalten NULL sein können.

Ein Feld mit einem NULL-Wert wurde während der Datensatzerstellung leer gelassen.

Beispiel

Der Wert NULL kann Probleme bei der Auswahl von Daten verursachen. Beim Vergleich eines unbekannten Werts mit einem anderen Wert ist das Ergebnis jedoch immer unbekannt und nicht in den Ergebnissen enthalten. Sie müssen die verwendenIS NULL oder IS NOT NULL Operatoren, um nach einem NULL-Wert zu suchen.

Betrachten Sie die folgende CUSTOMERS-Tabelle mit den unten gezeigten Datensätzen.

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |          |
|  7 | Muffy    |  24 | Indore    |          |
+----+----------+-----+-----------+----------+

Im Folgenden wird die Verwendung von IS NOT NULLOperator.

SQL> SELECT  ID, NAME, AGE, ADDRESS, SALARY
   FROM CUSTOMERS
   WHERE SALARY IS NOT NULL;

Dies würde das folgende Ergebnis erzeugen -

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
+----+----------+-----+-----------+----------+

Im Folgenden wird die Verwendung von IS NULL Operator.

SQL> SELECT  ID, NAME, AGE, ADDRESS, SALARY
   FROM CUSTOMERS
   WHERE SALARY IS NULL;

Dies würde das folgende Ergebnis erzeugen -

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  6 | Komal    |  22 | MP        |          |
|  7 | Muffy    |  24 | Indore    |          |
+----+----------+-----+-----------+----------+

SQL - Alias ​​Syntax

Sie können eine Tabelle oder eine Spalte vorübergehend umbenennen, indem Sie einen anderen Namen als Alias. Die Verwendung von Tabellenaliasnamen dient zum Umbenennen einer Tabelle in einer bestimmten SQL-Anweisung. Das Umbenennen ist eine vorübergehende Änderung und der tatsächliche Tabellenname ändert sich in der Datenbank nicht. Die Spaltenaliasnamen werden verwendet, um die Spalten einer Tabelle zum Zweck einer bestimmten SQL-Abfrage umzubenennen.

Syntax

Die grundlegende Syntax von a table Alias ​​ist wie folgt.

SELECT column1, column2....
FROM table_name AS alias_name
WHERE [condition];

Die grundlegende Syntax von a column Alias ​​ist wie folgt.

SELECT column_name AS alias_name
FROM table_name
WHERE [condition];

Beispiel

Betrachten Sie die folgenden zwei Tabellen.

Table 1 - KUNDENTabelle ist wie folgt.

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Table 2 - BESTELLUNGEN Die Tabelle lautet wie folgt.

+-----+---------------------+-------------+--------+
|OID  | DATE                | CUSTOMER_ID | AMOUNT |
+-----+---------------------+-------------+--------+
| 102 | 2009-10-08 00:00:00 |           3 |   3000 |
| 100 | 2009-10-08 00:00:00 |           3 |   1500 |
| 101 | 2009-11-20 00:00:00 |           2 |   1560 |
| 103 | 2008-05-20 00:00:00 |           4 |   2060 |
+-----+---------------------+-------------+--------+

Der folgende Codeblock zeigt nun die Verwendung von a table alias.

SQL> SELECT C.ID, C.NAME, C.AGE, O.AMOUNT 
   FROM CUSTOMERS AS C, ORDERS AS O
   WHERE  C.ID = O.CUSTOMER_ID;

Dies würde das folgende Ergebnis erzeugen.

+----+----------+-----+--------+
| ID | NAME     | AGE | AMOUNT |
+----+----------+-----+--------+
|  3 | kaushik  |  23 |   3000 |
|  3 | kaushik  |  23 |   1500 |
|  2 | Khilan   |  25 |   1560 |
|  4 | Chaitali |  25 |   2060 |
+----+----------+-----+--------+

Es folgt die Verwendung von a column alias.

SQL> SELECT  ID AS CUSTOMER_ID, NAME AS CUSTOMER_NAME
   FROM CUSTOMERS
   WHERE SALARY IS NOT NULL;

Dies würde das folgende Ergebnis erzeugen.

+-------------+---------------+
| CUSTOMER_ID | CUSTOMER_NAME |
+-------------+---------------+
|           1 | Ramesh        |
|           2 | Khilan        |
|           3 | kaushik       |
|           4 | Chaitali      |
|           5 | Hardik        |
|           6 | Komal         |
|           7 | Muffy         |
+-------------+---------------+

SQL - Indizes

Indizes sind special lookup tablesdass die Datenbanksuchmaschine verwenden kann, um das Abrufen von Daten zu beschleunigen. Einfach ausgedrückt ist ein Index ein Zeiger auf Daten in einer Tabelle. Ein Index in einer Datenbank ist einem Index am Ende eines Buches sehr ähnlich.

Wenn Sie beispielsweise auf alle Seiten in einem Buch verweisen möchten, in dem ein bestimmtes Thema behandelt wird, verweisen Sie zunächst auf den Index, in dem alle Themen alphabetisch aufgelistet sind, und verweisen dann auf eine oder mehrere bestimmte Seitenzahlen.

Ein Index hilft, schneller zu werden SELECT Anfragen und WHERE Klauseln, aber es verlangsamt die Dateneingabe mit dem UPDATE und die INSERTAussagen. Indizes können ohne Auswirkung auf die Daten erstellt oder gelöscht werden.

Das Erstellen eines Index umfasst die CREATE INDEX Anweisung, mit der Sie den Index benennen, die Tabelle und die zu indizierenden Spalten angeben und angeben können, ob der Index in aufsteigender oder absteigender Reihenfolge vorliegt.

Indizes können auch eindeutig sein, wie z UNIQUE Einschränkung, da der Index doppelte Einträge in der Spalte oder Kombination von Spalten verhindert, für die ein Index vorhanden ist.

Der Befehl CREATE INDEX

Die grundlegende Syntax von a CREATE INDEX ist wie folgt.

CREATE INDEX index_name ON table_name;

Einspaltige Indizes

Ein einspaltiger Index wird basierend auf nur einer Tabellenspalte erstellt. Die grundlegende Syntax lautet wie folgt.

CREATE INDEX index_name
ON table_name (column_name);

Einzigartige Indizes

Eindeutige Indizes werden nicht nur für die Leistung, sondern auch für die Datenintegrität verwendet. Mit einem eindeutigen Index können keine doppelten Werte in die Tabelle eingefügt werden. Die grundlegende Syntax lautet wie folgt.

CREATE UNIQUE INDEX index_name
on table_name (column_name);

Zusammengesetzte Indizes

Ein zusammengesetzter Index ist ein Index für zwei oder mehr Spalten einer Tabelle. Die grundlegende Syntax lautet wie folgt.

CREATE INDEX index_name
on table_name (column1, column2);

Berücksichtigen Sie beim Erstellen eines einspaltigen Index oder eines zusammengesetzten Index die Spalte (n), die Sie möglicherweise sehr häufig in der WHERE-Klausel einer Abfrage als Filterbedingungen verwenden.

Sollte nur eine Spalte verwendet werden, sollte ein einspaltiger Index die Wahl sein. Sollten in der WHERE-Klausel häufig zwei oder mehr Spalten als Filter verwendet werden, ist der zusammengesetzte Index die beste Wahl.

Implizite Indizes

Implizite Indizes sind Indizes, die vom Datenbankserver automatisch erstellt werden, wenn ein Objekt erstellt wird. Indizes werden automatisch für Primärschlüsseleinschränkungen und eindeutige Einschränkungen erstellt.

Der Befehl DROP INDEX

Ein Index kann mit SQL gelöscht werden DROPBefehl. Beim Löschen eines Index ist Vorsicht geboten, da sich die Performance entweder verlangsamen oder verbessern kann.

Die grundlegende Syntax lautet wie folgt:

DROP INDEX index_name;

Im Kapitel INDEX-Einschränkung finden Sie einige aktuelle Beispiele für Indizes.

Wann sollten Indizes vermieden werden?

Obwohl Indizes die Leistung einer Datenbank verbessern sollen, sollten sie manchmal vermieden werden.

Die folgenden Richtlinien geben an, wann die Verwendung eines Index überdacht werden sollte.

• Indizes sollten nicht für kleine Tabellen verwendet werden.

• Tabellen mit häufigen, umfangreichen Stapelaktualisierungen oder Einfügevorgängen.

• Indizes sollten nicht für Spalten verwendet werden, die eine hohe Anzahl von NULL-Werten enthalten.

• Häufig manipulierte Spalten sollten nicht indiziert werden.

SQL - Befehl ALTER TABLE

Die SQL ALTER TABLEMit diesem Befehl können Sie Spalten in einer vorhandenen Tabelle hinzufügen, löschen oder ändern. Sie sollten auch den Befehl ALTER TABLE verwenden, um verschiedene Einschränkungen für eine vorhandene Tabelle hinzuzufügen und zu löschen.

Syntax

Die grundlegende Syntax eines ALTER TABLE-Befehls zum Hinzufügen von a New Column in einer vorhandenen Tabelle ist wie folgt.

ALTER TABLE table_name ADD column_name datatype;

Die grundlegende Syntax eines ALTER TABLE-Befehls an DROP COLUMN in einer vorhandenen Tabelle ist wie folgt.

ALTER TABLE table_name DROP COLUMN column_name;

Die grundlegende Syntax eines ALTER TABLE-Befehls zum Ändern von DATA TYPE einer Spalte in einer Tabelle ist wie folgt.

ALTER TABLE table_name MODIFY COLUMN column_name datatype;

Die grundlegende Syntax eines ALTER TABLE-Befehls zum Hinzufügen von a NOT NULL Die Einschränkung für eine Spalte in einer Tabelle lautet wie folgt.

ALTER TABLE table_name MODIFY column_name datatype NOT NULL;

Die grundlegende Syntax von ALTER TABLE to ADD UNIQUE CONSTRAINT zu einer Tabelle ist wie folgt.

ALTER TABLE table_name 
ADD CONSTRAINT MyUniqueConstraint UNIQUE(column1, column2...);

Die grundlegende Syntax eines ALTER TABLE-Befehls an ADD CHECK CONSTRAINT zu einer Tabelle ist wie folgt.

ALTER TABLE table_name 
ADD CONSTRAINT MyUniqueConstraint CHECK (CONDITION);

Die grundlegende Syntax eines ALTER TABLE-Befehls an ADD PRIMARY KEY Die Einschränkung für eine Tabelle lautet wie folgt.

ALTER TABLE table_name 
ADD CONSTRAINT MyPrimaryKey PRIMARY KEY (column1, column2...);

Die grundlegende Syntax eines ALTER TABLE-Befehls an DROP CONSTRAINT aus einer Tabelle ist wie folgt.

ALTER TABLE table_name 
DROP CONSTRAINT MyUniqueConstraint;

Wenn Sie MySQL verwenden, lautet der Code wie folgt:

ALTER TABLE table_name 
DROP INDEX MyUniqueConstraint;

Die grundlegende Syntax eines ALTER TABLE-Befehls an DROP PRIMARY KEY Die Einschränkung aus einer Tabelle lautet wie folgt.

ALTER TABLE table_name 
DROP CONSTRAINT MyPrimaryKey;

Wenn Sie MySQL verwenden, lautet der Code wie folgt:

ALTER TABLE table_name 
DROP PRIMARY KEY;

Beispiel

Betrachten Sie die Tabelle CUSTOMERS mit den folgenden Datensätzen:

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Es folgt das Beispiel zum Hinzufügen von a New Column zu einer vorhandenen Tabelle -

ALTER TABLE CUSTOMERS ADD SEX char(1);

Jetzt wird die Tabelle CUSTOMERS geändert und das Folgende wird von der SELECT-Anweisung ausgegeben.

+----+---------+-----+-----------+----------+------+
| ID | NAME    | AGE | ADDRESS   | SALARY   | SEX  |
+----+---------+-----+-----------+----------+------+
|  1 | Ramesh  |  32 | Ahmedabad |  2000.00 | NULL |
|  2 | Ramesh  |  25 | Delhi     |  1500.00 | NULL |
|  3 | kaushik |  23 | Kota      |  2000.00 | NULL |
|  4 | kaushik |  25 | Mumbai    |  6500.00 | NULL |
|  5 | Hardik  |  27 | Bhopal    |  8500.00 | NULL |
|  6 | Komal   |  22 | MP        |  4500.00 | NULL |
|  7 | Muffy   |  24 | Indore    | 10000.00 | NULL |
+----+---------+-----+-----------+----------+------+

Das folgende Beispiel zeigt die Spalte DROP sex aus der vorhandenen Tabelle.

ALTER TABLE CUSTOMERS DROP SEX;

Jetzt wird die Tabelle CUSTOMERS geändert, und es folgt die Ausgabe der SELECT-Anweisung.

+----+---------+-----+-----------+----------+
| ID | NAME    | AGE | ADDRESS   | SALARY   |
+----+---------+-----+-----------+----------+
|  1 | Ramesh  |  32 | Ahmedabad |  2000.00 |
|  2 | Ramesh  |  25 | Delhi     |  1500.00 |
|  3 | kaushik |  23 | Kota      |  2000.00 |
|  4 | kaushik |  25 | Mumbai    |  6500.00 |
|  5 | Hardik  |  27 | Bhopal    |  8500.00 |
|  6 | Komal   |  22 | MP        |  4500.00 |
|  7 | Muffy   |  24 | Indore    | 10000.00 |
+----+---------+-----+-----------+----------+

SQL - Befehl TRUNCATE TABLE

Die SQL TRUNCATE TABLE Mit dem Befehl werden vollständige Daten aus einer vorhandenen Tabelle gelöscht.

Sie können auch den Befehl DROP TABLE verwenden, um die vollständige Tabelle zu löschen. Dadurch wird jedoch die vollständige Tabellenstruktur aus der Datenbank entfernt, und Sie müssen diese Tabelle erneut erstellen, wenn Sie einige Daten speichern möchten.

Syntax

Die grundlegende Syntax von a TRUNCATE TABLE Befehl ist wie folgt.

TRUNCATE TABLE  table_name;

Beispiel

Stellen Sie sich eine CUSTOMERS-Tabelle mit den folgenden Datensätzen vor:

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Das folgende Beispiel zeigt einen Befehl zum Abschneiden.

SQL > TRUNCATE TABLE CUSTOMERS;

Jetzt wird die Tabelle CUSTOMERS abgeschnitten und die Ausgabe der SELECT-Anweisung erfolgt wie im folgenden Codeblock gezeigt -

SQL> SELECT * FROM CUSTOMERS;
Empty set (0.00 sec)

SQL - Verwenden von Ansichten

Eine Ansicht ist nichts anderes als eine SQL-Anweisung, die in der Datenbank mit einem zugeordneten Namen gespeichert ist. Eine Ansicht ist eigentlich eine Zusammensetzung einer Tabelle in Form einer vordefinierten SQL-Abfrage.

Eine Ansicht kann alle Zeilen einer Tabelle enthalten oder Zeilen aus einer Tabelle auswählen. Eine Ansicht kann aus einer oder mehreren Tabellen erstellt werden. Dies hängt von der geschriebenen SQL-Abfrage ab, um eine Ansicht zu erstellen.

Mit Ansichten, bei denen es sich um eine Art virtueller Tabellen handelt, können Benutzer Folgendes tun:

• Strukturieren Sie Daten so, dass Benutzer oder Benutzerklassen sie natürlich oder intuitiv finden.

• Beschränken Sie den Zugriff auf die Daten so, dass ein Benutzer genau das sehen und (manchmal) ändern kann, was er benötigt, und nicht mehr.

• Fassen Sie Daten aus verschiedenen Tabellen zusammen, mit denen Berichte erstellt werden können.

Ansichten erstellen

Datenbankansichten werden mit dem erstellt CREATE VIEWErklärung. Ansichten können aus einer einzelnen Tabelle, mehreren Tabellen oder einer anderen Ansicht erstellt werden.

Um eine Ansicht zu erstellen, muss ein Benutzer über die entsprechenden Systemberechtigungen entsprechend der spezifischen Implementierung verfügen.

Das Grundlegende CREATE VIEW Die Syntax lautet wie folgt:

CREATE VIEW view_name AS
SELECT column1, column2.....
FROM table_name
WHERE [condition];

Sie können mehrere Tabellen in Ihre SELECT-Anweisung aufnehmen, ähnlich wie Sie sie in einer normalen SQL SELECT-Abfrage verwenden.

Beispiel

Betrachten Sie die Tabelle CUSTOMERS mit den folgenden Datensätzen:

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Im Folgenden finden Sie ein Beispiel zum Erstellen einer Ansicht aus der Tabelle CUSTOMERS. Diese Ansicht wird verwendet, um den Namen und das Alter des Kunden aus der Tabelle CUSTOMERS zu erhalten.

SQL > CREATE VIEW CUSTOMERS_VIEW AS
SELECT name, age
FROM  CUSTOMERS;

Jetzt können Sie CUSTOMERS_VIEW auf ähnliche Weise abfragen wie eine tatsächliche Tabelle. Das Folgende ist ein Beispiel dafür.

SQL > SELECT * FROM CUSTOMERS_VIEW;

Dies würde das folgende Ergebnis erzeugen.

+----------+-----+
| name     | age |
+----------+-----+
| Ramesh   |  32 |
| Khilan   |  25 |
| kaushik  |  23 |
| Chaitali |  25 |
| Hardik   |  27 |
| Komal    |  22 |
| Muffy    |  24 |
+----------+-----+

Die WITH CHECK-OPTION

Die WITH CHECK OPTION ist eine CREATE VIEW-Anweisungsoption. Mit der WITH CHECK-OPTION soll sichergestellt werden, dass alle UPDATE- und INSERTs die Bedingungen in der Ansichtsdefinition erfüllen.

Wenn sie die Bedingung (en) nicht erfüllen, gibt UPDATE oder INSERT einen Fehler zurück.

Der folgende Codeblock enthält ein Beispiel für das Erstellen derselben Ansicht CUSTOMERS_VIEW mit der WITH CHECK OPTION.

CREATE VIEW CUSTOMERS_VIEW AS
SELECT name, age
FROM  CUSTOMERS
WHERE age IS NOT NULL
WITH CHECK OPTION;

Die WITH CHECK-OPTION sollte in diesem Fall die Eingabe von NULL-Werten in die AGE-Spalte der Ansicht verweigern, da die Ansicht durch Daten definiert wird, die keinen NULL-Wert in der AGE-Spalte haben.

Eine Ansicht aktualisieren

Eine Ansicht kann unter bestimmten Bedingungen aktualisiert werden, die unten angegeben sind -

• Die SELECT-Klausel enthält möglicherweise nicht das Schlüsselwort DISTINCT.

• Die SELECT-Klausel enthält möglicherweise keine Zusammenfassungsfunktionen.

• Die SELECT-Klausel darf keine Set-Funktionen enthalten.

• Die SELECT-Klausel darf keine Set-Operatoren enthalten.

• Die SELECT-Klausel darf keine ORDER BY-Klausel enthalten.

• Die FROM-Klausel darf nicht mehrere Tabellen enthalten.

• Die WHERE-Klausel darf keine Unterabfragen enthalten.

• Die Abfrage enthält möglicherweise nicht GROUP BY oder HAVING.

• Berechnete Spalten werden möglicherweise nicht aktualisiert.

• Alle NOT NULL-Spalten aus der Basistabelle müssen in der Ansicht enthalten sein, damit die INSERT-Abfrage funktioniert.

Wenn eine Ansicht alle oben genannten Regeln erfüllt, können Sie diese Ansicht aktualisieren. Der folgende Codeblock enthält ein Beispiel zum Aktualisieren des Alters von Ramesh.

SQL > UPDATE CUSTOMERS_VIEW
   SET AGE = 35
   WHERE name = 'Ramesh';

Dies würde letztendlich die Basistabelle CUSTOMERS aktualisieren und dasselbe würde sich in der Ansicht selbst widerspiegeln. Versuchen Sie nun, die Basistabelle abzufragen, und die SELECT-Anweisung würde das folgende Ergebnis liefern.

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  35 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Einfügen von Zeilen in eine Ansicht

Datenzeilen können in eine Ansicht eingefügt werden. Die gleichen Regeln, die für den Befehl UPDATE gelten, gelten auch für den Befehl INSERT.

Hier können wir keine Zeilen in CUSTOMERS_VIEW einfügen, da wir nicht alle NOT NULL-Spalten in dieser Ansicht enthalten haben. Andernfalls können Sie Zeilen in einer Ansicht auf ähnliche Weise einfügen, wie Sie sie in eine Tabelle einfügen.

Zeilen in einer Ansicht löschen

Datenzeilen können aus einer Ansicht gelöscht werden. Die gleichen Regeln, die für die Befehle UPDATE und INSERT gelten, gelten auch für den Befehl DELETE.

Es folgt ein Beispiel zum Löschen eines Datensatzes mit AGE = 22.

SQL > DELETE FROM CUSTOMERS_VIEW
   WHERE age = 22;

Dies würde letztendlich eine Zeile aus der Basistabelle CUSTOMERS löschen und dasselbe würde sich in der Ansicht selbst widerspiegeln. Versuchen Sie nun, die Basistabelle abzufragen, und die SELECT-Anweisung würde das folgende Ergebnis liefern.

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  35 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Ansichten löschen

Wenn Sie eine Ansicht haben, müssen Sie die Ansicht natürlich löschen, wenn sie nicht mehr benötigt wird. Die Syntax ist sehr einfach und wird unten angegeben -

DROP VIEW view_name;

Im Folgenden finden Sie ein Beispiel zum Löschen von CUSTOMERS_VIEW aus der Tabelle CUSTOMERS.

DROP VIEW CUSTOMERS_VIEW;

SQL - Klausel haben

Das HAVING Clause Mit dieser Option können Sie Bedingungen angeben, die filtern, welche Gruppenergebnisse in den Ergebnissen angezeigt werden.

Die WHERE-Klausel legt Bedingungen für die ausgewählten Spalten fest, während die HAVING-Klausel Bedingungen für Gruppen festlegt, die mit der GROUP BY-Klausel erstellt wurden.

Syntax

Der folgende Codeblock zeigt die Position der HAVING-Klausel in einer Abfrage.

SELECT
FROM
WHERE
GROUP BY
HAVING
ORDER BY

Die HAVING-Klausel muss in einer Abfrage der GROUP BY-Klausel folgen und bei Verwendung auch der ORDER BY-Klausel vorangehen. Der folgende Codeblock hat die Syntax der SELECT-Anweisung einschließlich der HAVING-Klausel -

SELECT column1, column2
FROM table1, table2
WHERE [ conditions ]
GROUP BY column1, column2
HAVING [ conditions ]
ORDER BY column1, column2

Beispiel

Betrachten Sie die Tabelle CUSTOMERS mit den folgenden Datensätzen.

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Es folgt ein Beispiel, in dem ein Datensatz für eine ähnliche Alterszahl angezeigt wird, der größer oder gleich 2 ist.

SQL > SELECT ID, NAME, AGE, ADDRESS, SALARY
FROM CUSTOMERS
GROUP BY age
HAVING COUNT(age) >= 2;

Dies würde das folgende Ergebnis erzeugen -

+----+--------+-----+---------+---------+
| ID | NAME   | AGE | ADDRESS | SALARY  |
+----+--------+-----+---------+---------+
|  2 | Khilan |  25 | Delhi   | 1500.00 |
+----+--------+-----+---------+---------+

SQL - Transaktionen

Eine Transaktion ist eine Arbeitseinheit, die für eine Datenbank ausgeführt wird. Transaktionen sind Einheiten oder Abfolgen von Arbeiten, die in einer logischen Reihenfolge ausgeführt werden, entweder manuell von einem Benutzer oder automatisch von einer Art Datenbankprogramm.

Eine Transaktion ist die Weitergabe einer oder mehrerer Änderungen an der Datenbank. Wenn Sie beispielsweise einen Datensatz erstellen oder einen Datensatz aktualisieren oder einen Datensatz aus der Tabelle löschen, führen Sie eine Transaktion für diese Tabelle aus. Es ist wichtig, diese Transaktionen zu steuern, um die Datenintegrität sicherzustellen und Datenbankfehler zu behandeln.

In der Praxis werden Sie viele SQL-Abfragen zu einer Gruppe zusammenfassen und alle zusammen als Teil einer Transaktion ausführen.

Eigenschaften von Transaktionen

Transaktionen haben die folgenden vier Standardeigenschaften, die normalerweise mit dem Akronym bezeichnet werden ACID.

• Atomicity- stellt sicher, dass alle Vorgänge innerhalb der Arbeitseinheit erfolgreich abgeschlossen werden. Andernfalls wird die Transaktion zum Zeitpunkt des Ausfalls abgebrochen und alle vorherigen Vorgänge werden auf ihren vorherigen Status zurückgesetzt.

• Consistency - stellt sicher, dass die Datenbank bei einer erfolgreich festgeschriebenen Transaktion den Status ordnungsgemäß ändert.

• Isolation - ermöglicht es Transaktionen, unabhängig und transparent voneinander zu arbeiten.

• Durability - stellt sicher, dass das Ergebnis oder die Wirkung einer festgeschriebenen Transaktion bei einem Systemausfall bestehen bleibt.

Transaktionskontrolle

Die folgenden Befehle werden zur Steuerung von Transaktionen verwendet.

• COMMIT - um die Änderungen zu speichern.

• ROLLBACK - um die Änderungen zurückzusetzen.

• SAVEPOINT - Erstellt Punkte innerhalb der Transaktionsgruppen, in denen ROLLBACK ausgeführt werden soll.

• SET TRANSACTION - Platziert einen Namen in einer Transaktion.

Transaktionssteuerungsbefehle

Transaktionssteuerungsbefehle werden nur mit dem verwendet DML Commandswie - nur INSERT, UPDATE und DELETE. Sie können beim Erstellen oder Löschen von Tabellen nicht verwendet werden, da diese Vorgänge automatisch in der Datenbank festgeschrieben werden.

Der Befehl COMMIT

Der Befehl COMMIT ist der Transaktionsbefehl, mit dem Änderungen, die von einer Transaktion aufgerufen werden, in der Datenbank gespeichert werden.

Der Befehl COMMIT ist der Transaktionsbefehl, mit dem Änderungen, die von einer Transaktion aufgerufen werden, in der Datenbank gespeichert werden. Der Befehl COMMIT speichert alle Transaktionen seit dem letzten Befehl COMMIT oder ROLLBACK in der Datenbank.

Die Syntax für den Befehl COMMIT lautet wie folgt.

COMMIT;

Example

Betrachten Sie die Tabelle CUSTOMERS mit den folgenden Datensätzen:

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Im Folgenden finden Sie ein Beispiel, mit dem Datensätze aus der Tabelle mit dem Alter = 25 gelöscht und anschließend die Änderungen in der Datenbank festgeschrieben werden.

SQL> DELETE FROM CUSTOMERS
   WHERE AGE = 25;
SQL> COMMIT;

Somit würden zwei Zeilen aus der Tabelle gelöscht und die SELECT-Anweisung würde das folgende Ergebnis erzeugen.

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Der ROLLBACK-Befehl

Der Befehl ROLLBACK ist der Transaktionsbefehl, mit dem Transaktionen rückgängig gemacht werden, die noch nicht in der Datenbank gespeichert wurden. Dieser Befehl kann nur zum Rückgängigmachen von Transaktionen verwendet werden, seit der letzte Befehl COMMIT oder ROLLBACK ausgegeben wurde.

Die Syntax für einen ROLLBACK-Befehl lautet wie folgt:

ROLLBACK;

Example

Betrachten Sie die Tabelle CUSTOMERS mit den folgenden Datensätzen:

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Im Folgenden finden Sie ein Beispiel, mit dem die Datensätze aus der Tabelle mit dem Alter = 25 gelöscht und anschließend die Änderungen in der Datenbank rückgängig gemacht werden.

SQL> DELETE FROM CUSTOMERS
   WHERE AGE = 25;
SQL> ROLLBACK;

Somit würde der Löschvorgang keine Auswirkungen auf die Tabelle haben und die SELECT-Anweisung würde das folgende Ergebnis erzeugen.

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Der SAVEPOINT-Befehl

Ein SAVEPOINT ist ein Punkt in einer Transaktion, an dem Sie die Transaktion auf einen bestimmten Punkt zurücksetzen können, ohne die gesamte Transaktion zurückzusetzen.

Die Syntax für einen SAVEPOINT-Befehl lautet wie folgt.

SAVEPOINT SAVEPOINT_NAME;

Dieser Befehl dient nur zur Erstellung eines SAVEPOINT unter allen Transaktionsanweisungen. Der Befehl ROLLBACK wird verwendet, um eine Gruppe von Transaktionen rückgängig zu machen.

Die Syntax für das Zurücksetzen auf einen SAVEPOINT lautet wie folgt.

ROLLBACK TO SAVEPOINT_NAME;

Im Folgenden finden Sie ein Beispiel, in dem Sie die drei verschiedenen Datensätze aus der Tabelle CUSTOMERS löschen möchten. Sie möchten vor jedem Löschen einen SAVEPOINT erstellen, damit Sie jederzeit zu jedem SAVEPOINT zurückrollen können, um die entsprechenden Daten in den ursprünglichen Zustand zurückzusetzen.

Example

Betrachten Sie die Tabelle CUSTOMERS mit den folgenden Datensätzen.

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Der folgende Codeblock enthält die Reihe von Operationen.

SQL> SAVEPOINT SP1;
Savepoint created.
SQL> DELETE FROM CUSTOMERS WHERE ID=1;
1 row deleted.
SQL> SAVEPOINT SP2;
Savepoint created.
SQL> DELETE FROM CUSTOMERS WHERE ID=2;
1 row deleted.
SQL> SAVEPOINT SP3;
Savepoint created.
SQL> DELETE FROM CUSTOMERS WHERE ID=3;
1 row deleted.

Nachdem die drei Löschungen stattgefunden haben, nehmen wir an, dass Sie Ihre Meinung geändert und beschlossen haben, zu dem von Ihnen als SP2 identifizierten SAVEPOINT zurückzukehren. Da SP2 nach dem ersten Löschen erstellt wurde, werden die letzten beiden Löschvorgänge rückgängig gemacht.

SQL> ROLLBACK TO SP2;
Rollback complete.

Beachten Sie, dass nur das erste Löschen stattgefunden hat, seit Sie auf SP2 zurückgesetzt haben.

SQL> SELECT * FROM CUSTOMERS;
+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+
6 rows selected.

Der Befehl RELEASE SAVEPOINT

Mit dem Befehl RELEASE SAVEPOINT wird ein von Ihnen erstellter SAVEPOINT entfernt.

Die Syntax für einen Befehl RELEASE SAVEPOINT lautet wie folgt.

RELEASE SAVEPOINT SAVEPOINT_NAME;

Sobald ein SAVEPOINT freigegeben wurde, können Sie den Befehl ROLLBACK nicht mehr verwenden, um Transaktionen rückgängig zu machen, die seit dem letzten SAVEPOINT ausgeführt wurden.

Der Befehl SET TRANSACTION

Mit dem Befehl SET TRANSACTION kann eine Datenbanktransaktion initiiert werden. Mit diesem Befehl werden Merkmale für die folgende Transaktion angegeben. Beispielsweise können Sie eine Transaktion angeben, die schreibgeschützt oder schreibgeschützt sein soll.

Die Syntax für einen SET TRANSACTION-Befehl lautet wie folgt.

SET TRANSACTION [ READ WRITE | READ ONLY ];

SQL - Platzhalteroperatoren

Wir haben bereits über den SQL LIKE-Operator gesprochen, mit dem ein Wert mithilfe der Platzhalteroperatoren mit ähnlichen Werten verglichen wird.

SQL unterstützt zwei Platzhalteroperatoren in Verbindung mit dem LIKE-Operator, die in der folgenden Tabelle ausführlich erläutert werden.

Sr.Nr.	Platzhalter & Beschreibung
1	The percent sign (%) Entspricht einem oder mehreren Zeichen. Note - MS Access verwendet das Platzhalterzeichen (*) anstelle des Platzhalterzeichens (%) in Prozent.
2	The underscore (_) Entspricht einem Zeichen. Note - MS Access verwendet ein Fragezeichen (?) Anstelle des Unterstrichs (_), um einem Zeichen zu entsprechen.

Das Prozentzeichen steht für null, ein oder mehrere Zeichen. Der Unterstrich steht für eine einzelne Zahl oder ein Zeichen. Diese Symbole können in Kombinationen verwendet werden.

Syntax

Die grundlegende Syntax eines '%' - und eines '_'-Operators lautet wie folgt.

SELECT * FROM table_name
WHERE column LIKE 'XXXX%'

or 

SELECT * FROM table_name
WHERE column LIKE '%XXXX%'

or

SELECT * FROM table_name
WHERE column LIKE 'XXXX_'

or

SELECT * FROM table_name
WHERE column LIKE '_XXXX'

or

SELECT * FROM table_name
WHERE column LIKE '_XXXX_'

Sie können N Bedingungen mit den Operatoren AND oder OR kombinieren. Hier kann XXXX ein beliebiger numerischer Wert oder ein Zeichenfolgenwert sein.

Beispiel

Die folgende Tabelle enthält eine Reihe von Beispielen, die den WHERE-Teil mit unterschiedlichen LIKE-Klauseln mit den Operatoren '%' und '_' zeigen.

Sr.Nr.	Aussage & Beschreibung
1	WHERE SALARY LIKE '200%' Findet alle Werte, die mit 200 beginnen.
2	WHERE SALARY LIKE '%200%' Findet alle Werte mit 200 an einer beliebigen Position.
3	WHERE SALARY LIKE '_00%' Findet alle Werte mit 00 an der zweiten und dritten Position.
4	WHERE SALARY LIKE '2_%_%' Findet alle Werte, die mit 2 beginnen und mindestens 3 Zeichen lang sind.
5	WHERE SALARY LIKE '%2' Findet alle Werte, die mit 2 enden.
6	WHERE SALARY LIKE '_2%3' Findet alle Werte, die eine 2 an zweiter Stelle haben und mit einer 3 enden.
7	WHERE SALARY LIKE '2___3' Findet alle Werte in einer fünfstelligen Zahl, die mit 2 beginnen und mit 3 enden.

Nehmen wir ein reales Beispiel: Betrachten wir die Tabelle CUSTOMERS mit den folgenden Datensätzen.

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Der folgende Codeblock ist ein Beispiel, in dem alle Datensätze aus der Tabelle CUSTOMERS angezeigt werden, in der das Gehalt mit 200 beginnt.

SQL> SELECT * FROM CUSTOMERS
WHERE SALARY LIKE '200%';

Dies würde das folgende Ergebnis erzeugen.

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
+----+----------+-----+-----------+----------+

SQL - Datumsfunktionen

Die folgende Tabelle enthält eine Liste aller wichtigen Funktionen für Datum und Uhrzeit, die über SQL verfügbar sind. Es gibt verschiedene andere Funktionen, die von Ihrem RDBMS unterstützt werden. Die angegebene Liste basiert auf MySQL RDBMS.

Sr.Nr.	Bedienungsanleitung
1	DATUM HINZUFÜGEN() Fügt Daten hinzu
2	ZEIT HINZUFÜGEN() Fügt Zeit hinzu
3	CONVERT_TZ () Konvertiert von einer Zeitzone in eine andere
4	CURDATE () Gibt das aktuelle Datum zurück
5	CURRENT_DATE (), CURRENT_DATE Synonyme für CURDATE ()
6	CURRENT_TIME (), CURRENT_TIME Synonyme für CURTIME ()
7	CURRENT_TIMESTAMP (), CURRENT_TIMESTAMP Synonyme für JETZT ()
8	CURTIME () Gibt die aktuelle Zeit zurück
9	DATE_ADD () Fügt zwei Daten hinzu
10	DATUMSFORMAT() Formatiert das Datum wie angegeben
11	DATE_SUB () Subtrahiert zwei Daten
12	DATUM() Extrahiert den Datumsteil eines Datums- oder Datums- / Uhrzeitausdrucks
13	DATEDIFF () Subtrahiert zwei Daten
14	TAG() Synonym für DAYOFMONTH ()
15	TAGNAME () Gibt den Namen des Wochentags zurück
16	MONATSTAG() Gibt den Tag des Monats zurück (1-31)
17	WOCHENTAG() Gibt den Wochentagsindex des Arguments zurück
18	DAYOFYEAR () Gibt den Tag des Jahres zurück (1-366)
19	EXTRAKT Extrahiert einen Teil eines Datums
20	FROM_DAYS () Konvertiert eine Tagesnummer in ein Datum
21	FROM_UNIXTIME () Formatiert das Datum als UNIX-Zeitstempel
22	STUNDE() Extrahiert die Stunde
23	LETZTER TAG Gibt den letzten Tag des Monats für das Argument zurück
24	LOCALTIME (), LOCALTIME Synonym für JETZT ()
25	LOCALTIMESTAMP, LOCALTIMESTAMP () Synonym für JETZT ()
26	MAKEDATE () Erstellt ein Datum aus dem Jahr und dem Tag des Jahres
27	ZEIT SCHAFFEN ZEIT SCHAFFEN()
28	MIKROSEKUNDE() Gibt die Mikrosekunden vom Argument zurück
29	MINUTE() Gibt die Minute des Arguments zurück
30	MONAT() Geben Sie den Monat ab dem abgelaufenen Datum zurück
31	MONTHNAME () Gibt den Namen des Monats zurück
32	JETZT() Gibt das aktuelle Datum und die aktuelle Uhrzeit zurück
33	PERIOD_ADD () Fügt einem Jahr-Monat einen Zeitraum hinzu
34	PERIOD_DIFF () Gibt die Anzahl der Monate zwischen den Perioden zurück
35	QUARTAL() Gibt das Quartal von einem Datumsargument zurück
36	SEC_TO_TIME () Konvertiert Sekunden in das Format 'HH: MM: SS'
37	ZWEITE() Gibt die Sekunde zurück (0-59)
38	STR_TO_DATE () Konvertiert eine Zeichenfolge in ein Datum
39	SUBDATE () Bei Aufruf mit drei Argumenten ein Synonym für DATE_SUB ()
40	SUBTIME () Subtrahiert mal
41	SYSDATE () Gibt den Zeitpunkt zurück, zu dem die Funktion ausgeführt wird
42	ZEITFORMAT() Formate als Zeit
43	TIME_TO_SEC () Gibt das in Sekunden konvertierte Argument zurück
44	ZEIT() Extrahiert den Zeitanteil des übergebenen Ausdrucks
45	TIMEDIFF () Subtrahiert die Zeit
46	TIMESTAMP () Mit einem einzigen Argument gibt diese Funktion den Datums- oder Datums- / Uhrzeitausdruck zurück. Mit zwei Argumenten die Summe der Argumente
47	TIMESTAMPADD () Fügt einem Datum / Uhrzeit-Ausdruck ein Intervall hinzu
48	TIMESTAMPDIFF () Subtrahiert ein Intervall von einem Datum / Uhrzeit-Ausdruck
49	TO_DAYS () Gibt das in Tage konvertierte Datumsargument zurück
50	UNIX_TIMESTAMP () Gibt einen UNIX-Zeitstempel zurück
51	UTC_DATE () Gibt das aktuelle UTC-Datum zurück
52	UTC_TIME () Gibt die aktuelle UTC-Zeit zurück
53	UTC_TIMESTAMP () Gibt das aktuelle UTC-Datum und die Uhrzeit zurück
54	WOCHE() Gibt die Wochennummer zurück
55	WOCHENTAG() Gibt den Wochentagsindex zurück
56	WOCHENTAG () Gibt die Kalenderwoche des Datums zurück (1-53)
57	JAHR() Gibt das Jahr zurück
58	JAHRESWOCHE () Gibt das Jahr und die Woche zurück

ADDDATE (Datum, INTERVALL Ausdruckseinheit), ADDDATE (Ausdruck, Tage)

Beim Aufrufen mit der INTERVAL-Form des zweiten Arguments ist ADDDATE () ein Synonym für DATE_ADD (). Die zugehörige Funktion SUBDATE () ist ein Synonym für DATE_SUB (). Informationen zum Argument INTERVAL unit finden Sie in der Diskussion zu DATE_ADD ().

mysql> SELECT DATE_ADD('1998-01-02', INTERVAL 31 DAY);
+---------------------------------------------------------+
| DATE_ADD('1998-01-02', INTERVAL 31 DAY)                 |
+---------------------------------------------------------+
| 1998-02-02                                              |
+---------------------------------------------------------+
1 row in set (0.00 sec)

mysql> SELECT ADDDATE('1998-01-02', INTERVAL 31 DAY);
+---------------------------------------------------------+
| ADDDATE('1998-01-02', INTERVAL 31 DAY)                  |
+---------------------------------------------------------+
| 1998-02-02                                              |
+---------------------------------------------------------+
1 row in set (0.00 sec)

Wenn MySQL mit der Tagesform des zweiten Arguments aufgerufen wird, behandelt es diese als eine ganzzahlige Anzahl von Tagen, die zu expr hinzugefügt werden sollen.

mysql> SELECT ADDDATE('1998-01-02', 31);
+---------------------------------------------------------+
| DATE_ADD('1998-01-02', INTERVAL 31 DAY)                 |
+---------------------------------------------------------+
| 1998-02-02                                              |
+---------------------------------------------------------+
1 row in set (0.00 sec)

ADDTIME (Ausdruck1, Ausdruck2)

ADDTIME () fügt expr2 zu expr1 hinzu und gibt das Ergebnis zurück. Der Ausdruck1 ist ein Zeit- oder Datums- / Uhrzeitausdruck, während der Ausdruck2 ein Zeitausdruck ist.

mysql> SELECT ADDTIME('1997-12-31 23:59:59.999999','1 1:1:1.000002');
+---------------------------------------------------------+
| DATE_ADD('1997-12-31 23:59:59.999999','1 1:1:1.000002') |
+---------------------------------------------------------+
| 1998-01-02 01:01:01.000001                              |
+---------------------------------------------------------+
1 row in set (0.00 sec)

CONVERT_TZ (dt, from_tz, to_tz)

Dies konvertiert einen Datums- / Uhrzeitwert dt von der durch from_tz angegebenen Zeitzone in die durch to_tz angegebene Zeitzone und gibt den resultierenden Wert zurück. Diese Funktion gibt NULL zurück, wenn die Argumente ungültig sind.

mysql> SELECT CONVERT_TZ('2004-01-01 12:00:00','GMT','MET');
+---------------------------------------------------------+
| CONVERT_TZ('2004-01-01 12:00:00','GMT','MET')           |
+---------------------------------------------------------+
| 2004-01-01 13:00:00                                     |
+---------------------------------------------------------+
1 row in set (0.00 sec)

mysql> SELECT CONVERT_TZ('2004-01-01 12:00:00','+00:00','+10:00');
+---------------------------------------------------------+
| CONVERT_TZ('2004-01-01 12:00:00','+00:00','+10:00')     |
+---------------------------------------------------------+
| 2004-01-01 22:00:00                                     |
+---------------------------------------------------------+
1 row in set (0.00 sec)

CURDATE ()

Gibt das aktuelle Datum als Wert im Format 'JJJJ-MM-TT' oder JJJJMMTT zurück, je nachdem, ob die Funktion in einer Zeichenfolge oder in einem numerischen Kontext verwendet wird.

mysql> SELECT CURDATE();
+---------------------------------------------------------+
| CURDATE()                                               |
+---------------------------------------------------------+
| 1997-12-15                                              |
+---------------------------------------------------------+
1 row in set (0.00 sec)

mysql> SELECT CURDATE() + 0;
+---------------------------------------------------------+
| CURDATE() + 0                                           |
+---------------------------------------------------------+
| 19971215                                                |
+---------------------------------------------------------+
1 row in set (0.00 sec)

CURRENT_DATE und CURRENT_DATE ()

CURRENT_DATE und CURRENT_DATE () sind Synonyme für CURDATE ()

CURTIME ()

Gibt die aktuelle Zeit als Wert im Format 'HH: MM: SS' oder HHMMSS zurück, je nachdem, ob die Funktion in einer Zeichenfolge oder in einem numerischen Kontext verwendet wird. Der Wert wird in der aktuellen Zeitzone ausgedrückt.

mysql> SELECT CURTIME();
+---------------------------------------------------------+
| CURTIME()                                               |
+---------------------------------------------------------+
| 23:50:26                                                |
+---------------------------------------------------------+
1 row in set (0.00 sec)

mysql> SELECT CURTIME() + 0;
+---------------------------------------------------------+
| CURTIME() + 0                                           |
+---------------------------------------------------------+
| 235026                                                  |
+---------------------------------------------------------+
1 row in set (0.00 sec)

CURRENT_TIME und CURRENT_TIME ()

CURRENT_TIME und CURRENT_TIME () sind Synonyme für CURTIME ().

CURRENT_TIMESTAMP und CURRENT_TIMESTAMP ()

CURRENT_TIMESTAMP und CURRENT_TIMESTAMP () sind Synonyme für NOW ().

DATUM (Ausdruck)

Extrahiert den Datumsteil des Datums- oder Datums- / Uhrzeitausdrucks Ausdruck.

mysql> SELECT DATE('2003-12-31 01:02:03');
+---------------------------------------------------------+
| DATE('2003-12-31 01:02:03')                             |
+---------------------------------------------------------+
|  2003-12-31                                             |
+---------------------------------------------------------+
1 row in set (0.00 sec)

DATEDIFF (Ausdruck1, Ausdruck2)

DATEDIFF () gibt expr1 zurück. Ausdruck2 ausgedrückt als Wert in Tagen von einem Datum zum anderen. Sowohl Ausdruck1 als auch Ausdruck2 sind Datums- oder Datums- und Uhrzeitausdrücke. Bei der Berechnung werden nur die Datumsteile der Werte verwendet.

mysql> SELECT DATEDIFF('1997-12-31 23:59:59','1997-12-30');
+---------------------------------------------------------+
| DATEDIFF('1997-12-31 23:59:59','1997-12-30')            |
+---------------------------------------------------------+
| 1                                                       |
+---------------------------------------------------------+
1 row in set (0.00 sec)

DATE_ADD (Datum, INTERVAL-Ausdruckseinheit), DATE_SUB (Datum, INTERVAL-Ausdruckseinheit)

Diese Funktionen führen eine Datumsarithmetik durch. Dasdateist ein DATETIME- oder DATE-Wert, der das Startdatum angibt. Dasexprist ein Ausdruck, der den Intervallwert angibt, der vom Startdatum addiert oder subtrahiert werden soll. Der Ausdruck ist eine Zeichenfolge; es kann mit einem '-' für negative Intervalle beginnen.

EIN unit ist ein Schlüsselwort, das die Einheiten angibt, in denen der Ausdruck interpretiert werden soll.

Das INTERVAL Das Schlüsselwort und der Einheitenspezifizierer unterscheiden nicht zwischen Groß- und Kleinschreibung.

Die folgende Tabelle zeigt die erwartete Form des expr-Arguments für jeden Einheitswert.

Einheit Wert	Erwartetes exprFormat
MIKROSEKUNDE	MIKROSECONDS
ZWEITE	SEKUNDEN
MINUTE	PROTOKOLL
STUNDE	STD
TAG	TAGE
WOCHE	WOCHEN
MONAT	MONATE
QUARTAL	Viertel
JAHR	JAHRE
SECOND_MICROSECOND	'SECONDS.MICROSECONDS'
MINUTE_MICROSECOND	'MINUTES.MICROSECONDS'
MINUTE_SECOND	"MINUTEN: SEKUNDEN"
HOUR_MICROSECOND	'HOURS.MICROSECONDS'
HOUR_SECOND	"STUNDEN: MINUTEN: SEKUNDEN"
HOUR_MINUTE	"STUNDEN: MINUTEN"
DAY_MICROSECOND	'DAYS.MICROSECONDS'
DAY_SECOND	"TAGE STUNDEN: MINUTEN: SEKUNDEN"
DAY_MINUTE	"TAGE STUNDEN: MINUTEN"
DAY_HOUR	"TAGE STUNDEN"
JAHR MONAT	"JAHRE-MONATE"

Die Werte QUARTER und WEEKsind in MySQL 5.0.0 verfügbar. Ausführung.

mysql> SELECT DATE_ADD('1997-12-31 23:59:59', 
   -> INTERVAL '1:1' MINUTE_SECOND);
+---------------------------------------------------------+
| DATE_ADD('1997-12-31 23:59:59', INTERVAL...             |
+---------------------------------------------------------+
| 1998-01-01 00:01:00                                     |
+---------------------------------------------------------+
1 row in set (0.00 sec)

mysql> SELECT DATE_ADD('1999-01-01', INTERVAL 1 HOUR);
+---------------------------------------------------------+
| DATE_ADD('1999-01-01', INTERVAL 1 HOUR)                 |
+---------------------------------------------------------+
| 1999-01-01 01:00:00                                     |
+---------------------------------------------------------+
1 row in set (0.00 sec)

DATE_FORMAT (Datum, Format)

Dieser Befehl formatiert den Datumswert gemäß der Formatzeichenfolge.

Die folgenden Bezeichner können in der Formatzeichenfolge verwendet werden. Das Zeichen '%' ist vor den Formatbezeichnerzeichen erforderlich.

Sr.Nr.	Spezifizierer & Beschreibung
1	%a Abgekürzter Wochentagsname (Sun..Sat)
2	%b Abgekürzter Monatsname (Jan..Dec)
3	%c Monat, numerisch (0..12)
4	%D Tag des Monats mit englischem Suffix (0., 1., 2., 3.,.)
5	%d Tag des Monats, numerisch (00..31)
6	%e Tag des Monats, numerisch (0..31)
7	%f Mikrosekunden (000000..999999)
8	%H Stunde (00..23)
9	%h Stunde (01..12)
10	%I Stunde (01..12)
11	%i Minuten, numerisch (00..59)
12	%j Tag des Jahres (001..366)
13	%k Stunde (0..23)
14	%l Stunde (1..12)
15	%M Monatsname (Januar..Dezember)
16	%m Monat, numerisch (00..12)
17	%p Vormittags oder nachmittags
18	%r Zeit 12 Stunden (hh: mm: ss gefolgt von AM oder PM)
19	%S Sekunden (00..59)
20	%s Sekunden (00..59)
21	%T Zeit, 24 Stunden (hh: mm: ss)
22	%U Woche (00..53), wobei Sonntag der erste Tag der Woche ist
23	%u Woche (00..53), wobei Montag der erste Tag der Woche ist
24	%V Woche (01..53), wobei Sonntag der erste Tag der Woche ist; verwendet mit% X.
25	%v Woche (01..53), wobei Montag der erste Tag der Woche ist; verwendet mit% x
26	%W Wochentagsname (Sonntag..Samstag)
27	%w Wochentag (0 = Sonntag..6 = Samstag)
28	%X Jahr für die Woche, in der Sonntag der erste Tag der Woche ist, numerisch, vierstellig; verwendet mit% V.
29	%x Jahr für die Woche, wobei Montag der erste Tag der Woche ist, numerisch, vierstellig; verwendet mit% v
30	%Y Jahr, numerisch, vierstellig
31	%y Jahr, numerisch (zweistellig)
32	%% Ein wörtliches%. Charakter
33	%x x, für any.x. oben nicht aufgeführt

mysql> SELECT DATE_FORMAT('1997-10-04 22:23:00', '%W %M %Y');
+---------------------------------------------------------+
| DATE_FORMAT('1997-10-04 22:23:00', '%W %M %Y')          |
+---------------------------------------------------------+
| Saturday October 1997                                   |
+---------------------------------------------------------+
1 row in set (0.00 sec)

mysql> SELECT DATE_FORMAT('1997-10-04 22:23:00'
   -> '%H %k %I %r %T %S %w');
+---------------------------------------------------------+
| DATE_FORMAT('1997-10-04 22:23:00.......                 |
+---------------------------------------------------------+
|  22 22 10 10:23:00 PM 22:23:00 00 6                     |
+---------------------------------------------------------+
1 row in set (0.00 sec)

DATE_SUB (Datum, INTERVAL Ausdruckseinheit)

Dies ähnelt der Funktion DATE_ADD ().

TAG (Datum)

Das DAY () ist ein Synonym für die Funktion DAYOFMONTH ().

TAGNAME (Datum)

Gibt den Namen des Wochentags für das Datum zurück.

mysql> SELECT DAYNAME('1998-02-05');
+---------------------------------------------------------+
| DAYNAME('1998-02-05')                                   |
+---------------------------------------------------------+
| Thursday                                                |
+---------------------------------------------------------+
1 row in set (0.00 sec)

DAYOFMONTH (Datum)

Gibt den Tag des Monats für das Datum im Bereich von 0 bis 31 zurück.

mysql> SELECT DAYOFMONTH('1998-02-03');
+---------------------------------------------------------+
| DAYOFMONTH('1998-02-03')                                |
+---------------------------------------------------------+
| 3                                                       |
+---------------------------------------------------------+
1 row in set (0.00 sec)

DAYOFWEEK (Datum)

Gibt den Wochentagsindex für das Datum zurück (1 = Sonntag, 2 = Montag,., 7 = Samstag). Diese Indexwerte entsprechen dem ODBC-Standard.

mysql> SELECT DAYOFWEEK('1998-02-03');
+---------------------------------------------------------+
|DAYOFWEEK('1998-02-03')                                  |
+---------------------------------------------------------+
| 3                                                       |
+---------------------------------------------------------+
1 row in set (0.00 sec)

DAYOFYEAR (Datum)

Gibt den Tag des Jahres für das Datum im Bereich von 1 bis 366 zurück.

mysql> SELECT DAYOFYEAR('1998-02-03');
+---------------------------------------------------------+
| DAYOFYEAR('1998-02-03')                                 |
+---------------------------------------------------------+
| 34                                                      |
+---------------------------------------------------------+
1 row in set (0.00 sec)

EXTRAKT (Einheit AB Datum)

Die EXTRACT () -Funktion verwendet die gleichen Arten von Einheitenspezifizierern wie DATE_ADD () oder DATE_SUB (), extrahiert jedoch Teile aus dem Datum, anstatt eine Datumsarithmetik durchzuführen.

mysql> SELECT EXTRACT(YEAR FROM '1999-07-02');
+---------------------------------------------------------+
| EXTRACT(YEAR FROM '1999-07-02')                         |
+---------------------------------------------------------+
| 1999                                                    |
+---------------------------------------------------------+
1 row in set (0.00 sec)

mysql> SELECT EXTRACT(YEAR_MONTH FROM '1999-07-02 01:02:03');
+---------------------------------------------------------+
| EXTRACT(YEAR_MONTH FROM '1999-07-02 01:02:03')          |
+---------------------------------------------------------+
| 199907                                                  |
+---------------------------------------------------------+
1 row in set (0.00 sec)

FROM_DAYS (N)

Gibt bei einer Tagesnummer N einen DATE-Wert zurück.

mysql> SELECT FROM_DAYS(729669);
+---------------------------------------------------------+
| FROM_DAYS(729669)                                       |
+---------------------------------------------------------+
| 1997-10-07                                              |
+---------------------------------------------------------+
1 row in set (0.00 sec)

Note- Verwenden Sie FROM_DAYS () mit Vorsicht bei alten Daten. Es ist nicht zur Verwendung mit Werten vorgesehen, die dem Aufkommen des Gregorianischen Kalenders (1582) vorausgehen.

FROM_UNIXTIME (unix_timestamp)

FROM_UNIXTIME (unix_timestamp, Format)

Gibt eine Darstellung des zurück unix_timestampArgument als Wert im Format 'JJJJ-MM-TT HH: MM: SS oder JJJJMMTTHHMMSS, je nachdem, ob die Funktion in einer Zeichenfolge oder in einem numerischen Kontext verwendet wird. Der Wert wird in der aktuellen Zeitzone ausgedrückt. Das Argument unix_timestamp ist ein interner Zeitstempelwert, der von der erzeugt wirdUNIX_TIMESTAMP() Funktion.

Wenn das Format angegeben ist, wird das Ergebnis gemäß der Formatzeichenfolge formatiert, die auf die gleiche Weise verwendet wird, wie sie im Eintrag für aufgeführt ist DATE_FORMAT() Funktion.

mysql> SELECT FROM_UNIXTIME(875996580);
+---------------------------------------------------------+
| FROM_UNIXTIME(875996580)                                |
+---------------------------------------------------------+
| 1997-10-04 22:23:00                                     |
+---------------------------------------------------------+
1 row in set (0.00 sec)

STUNDE (Zeit)

Gibt die Stunde für die Zeit zurück. Der Bereich des Rückgabewerts liegt bei Tageszeitwerten zwischen 0 und 23. Der Bereich der TIME-Werte ist jedoch tatsächlich viel größer, sodass HOUR Werte größer als 23 zurückgeben kann.

mysql> SELECT HOUR('10:05:03');
+---------------------------------------------------------+
| HOUR('10:05:03')                                        |
+---------------------------------------------------------+
| 10                                                      |
+---------------------------------------------------------+
1 row in set (0.00 sec)

LAST_DAY (Datum)

Nimmt einen Datums- oder Datums- / Uhrzeitwert und gibt den entsprechenden Wert für den letzten Tag des Monats zurück. Gibt NULL zurück, wenn das Argument ungültig ist.

mysql> SELECT LAST_DAY('2003-02-05');
+---------------------------------------------------------+
| LAST_DAY('2003-02-05')                                  |
+---------------------------------------------------------+
| 2003-02-28                                              |
+---------------------------------------------------------+
1 row in set (0.00 sec)

LOCALTIME und LOCALTIME ()

LOCALTIME und LOCALTIME () sind Synonyme für NOW ().

LOCALTIMESTAMP und LOCALTIMESTAMP ()

LOCALTIMESTAMP und LOCALTIMESTAMP () sind Synonyme für NOW ().

MAKEDATE (Jahr, Tag des Jahres)

Gibt ein Datum mit den angegebenen Werten für Jahr und Tag zurück. Der Tageswert muss größer als 0 sein, sonst ist das Ergebnis NULL.

mysql> SELECT MAKEDATE(2001,31), MAKEDATE(2001,32);
+---------------------------------------------------------+
| MAKEDATE(2001,31), MAKEDATE(2001,32)                    |
+---------------------------------------------------------+
| '2001-01-31', '2001-02-01'                              |
+---------------------------------------------------------+
1 row in set (0.00 sec)

MAKETIME (Stunde, Minute, Sekunde)

Gibt einen Zeitwert zurück, der aus den Argumenten Stunde, Minute und Sekunde berechnet wird.

mysql> SELECT MAKETIME(12,15,30);
+---------------------------------------------------------+
| MAKETIME(12,15,30)                                      |
+---------------------------------------------------------+
| '12:15:30'                                              |
+---------------------------------------------------------+
1 row in set (0.00 sec)

MIKROSEKUNDE (Ausdruck)

Gibt die Mikrosekunden vom Zeit- oder Datums- / Uhrzeitausdruck (Ausdruck) als Zahl im Bereich von 0 bis 999999 zurück.

mysql> SELECT MICROSECOND('12:00:00.123456');
+---------------------------------------------------------+
| MICROSECOND('12:00:00.123456')                          |
+---------------------------------------------------------+
| 123456                                                  |
+---------------------------------------------------------+
1 row in set (0.00 sec)

MINUTE (Zeit)

Gibt die Zeitminute im Bereich von 0 bis 59 zurück.

mysql> SELECT MINUTE('98-02-03 10:05:03');
+---------------------------------------------------------+
| MINUTE('98-02-03 10:05:03')                             |
+---------------------------------------------------------+
| 5                                                       |
+---------------------------------------------------------+
1 row in set (0.00 sec)

Monatsdatum)

Gibt den Monat für das Datum im Bereich von 0 bis 12 zurück.

mysql> SELECT MONTH('1998-02-03')
+---------------------------------------------------------+
| MONTH('1998-02-03')                                     |
+---------------------------------------------------------+
| 2                                                       |
+---------------------------------------------------------+
1 row in set (0.00 sec)

MONTHNAME (Datum)

Gibt den vollständigen Namen des Monats für ein Datum zurück.

mysql> SELECT MONTHNAME('1998-02-05');
+---------------------------------------------------------+
| MONTHNAME('1998-02-05')                                 |
+---------------------------------------------------------+
| February                                                |
+---------------------------------------------------------+
1 row in set (0.00 sec)

JETZT()

Gibt das aktuelle Datum und die aktuelle Uhrzeit als Wert im Format 'JJJJ-MM-TT HH: MM: SS' oder JJJJMMTTHHMMSS zurück, je nachdem, ob die Funktion in einer Zeichenfolge oder einem numerischen Kontext verwendet wird. Dieser Wert wird in der aktuellen Zeitzone ausgedrückt.

mysql> SELECT NOW();
+---------------------------------------------------------+
| NOW()                                                   |
+---------------------------------------------------------+
| 1997-12-15 23:50:26                                     |
+---------------------------------------------------------+
1 row in set (0.00 sec)

PERIOD_ADD (P, N)

Fügt einem Zeitraum P N Monate hinzu (im Format JJJM oder JJJJMM). Gibt einen Wert im Format JJJJMM zurück. Beachten Sie, dass das Periodenargument P kein Datumswert ist.

mysql> SELECT PERIOD_ADD(9801,2);
+---------------------------------------------------------+
| PERIOD_ADD(9801,2)                                      |
+---------------------------------------------------------+
| 199803                                                  |
+---------------------------------------------------------+
1 row in set (0.00 sec)

PERIOD_DIFF (P1, P2)

Gibt die Anzahl der Monate zwischen den Perioden P1 und P2 zurück. Diese Zeiträume P1 und P2 sollten das Format JJMM oder JJJJMM haben. Beachten Sie, dass die Periodenargumente P1 und P2 keine Datumswerte sind.

mysql> SELECT PERIOD_DIFF(9802,199703);
+---------------------------------------------------------+
| PERIOD_DIFF(9802,199703)                                |
+---------------------------------------------------------+
| 11                                                      |
+---------------------------------------------------------+
1 row in set (0.00 sec)

QUARTAL (Datum)

Gibt das Quartal des Datumsquartals im Bereich von 1 bis 4 zurück.

mysql> SELECT QUARTER('98-04-01');
+---------------------------------------------------------+
| QUARTER('98-04-01')                                     |
+---------------------------------------------------------+
| 2                                                       |
+---------------------------------------------------------+
1 row in set (0.00 sec)

Zweites Mal)

Gibt die Sekunde für die Zeit im Bereich von 0 bis 59 zurück.

mysql> SELECT SECOND('10:05:03');
+---------------------------------------------------------+
| SECOND('10:05:03')                                      |
+---------------------------------------------------------+
| 3                                                       |
+---------------------------------------------------------+
1 row in set (0.00 sec)

SEC_TO_TIME (Sekunden)

Gibt das in Stunden, Minuten und Sekunden konvertierte Sekundenargument als Wert im Format 'HH: MM: SS' oder HHMMSS zurück, je nachdem, ob die Funktion in einer Zeichenfolge oder einem numerischen Kontext verwendet wird.

mysql> SELECT SEC_TO_TIME(2378);
+---------------------------------------------------------+
| SEC_TO_TIME(2378)                                       |
+---------------------------------------------------------+
| 00:39:38                                                |
+---------------------------------------------------------+
1 row in set (0.00 sec)

STR_TO_DATE (str, format)

Dies ist die Umkehrung der Funktion DATE_FORMAT (). Es werden ein String-Str und ein Format-String-Format verwendet. Die Funktion STR_TO_DATE () gibt einen DATETIME-Wert zurück, wenn die Formatzeichenfolge sowohl Datums- als auch Zeitteile enthält. Andernfalls wird ein DATE- oder TIME-Wert zurückgegeben, wenn die Zeichenfolge nur Datums- oder Zeitteile enthält.

mysql> SELECT STR_TO_DATE('04/31/2004', '%m/%d/%Y');
+---------------------------------------------------------+
| STR_TO_DATE('04/31/2004', '%m/%d/%Y')                   |
+---------------------------------------------------------+
| 2004-04-31                                              |
+---------------------------------------------------------+
1 row in set (0.00 sec)

SUBDATE (Datum, INTERVALL expr Einheit) und SUBDATE (expr, Tage)

Beim Aufrufen mit der INTERVAL-Form des zweiten Arguments ist SUBDATE () ein Synonym für DATE_SUB (). Informationen zum Argument INTERVAL unit finden Sie in der Diskussion zu DATE_ADD ().

mysql> SELECT DATE_SUB('1998-01-02', INTERVAL 31 DAY);
+---------------------------------------------------------+
| DATE_SUB('1998-01-02', INTERVAL 31 DAY)                 |
+---------------------------------------------------------+
| 1997-12-02                                              |
+---------------------------------------------------------+
1 row in set (0.00 sec)

mysql> SELECT SUBDATE('1998-01-02', INTERVAL 31 DAY);
+---------------------------------------------------------+
| SUBDATE('1998-01-02', INTERVAL 31 DAY)                  |
+---------------------------------------------------------+
| 1997-12-02                                              |
+---------------------------------------------------------+
1 row in set (0.00 sec)

SUBTIME (Ausdruck1, Ausdruck2)

Die Funktion SUBTIME () gibt expr1 zurück. Ausdruck2 ausgedrückt als Wert im gleichen Format wie Ausdruck1. Der expr1-Wert ist ein Zeit- oder ein datetime-Ausdruck, während der expr2-Wert ein Zeitausdruck ist.

mysql> SELECT SUBTIME('1997-12-31 23:59:59.999999',
   -> '1 1:1:1.000002');
+---------------------------------------------------------+
| SUBTIME('1997-12-31 23:59:59.999999'...                 |
+---------------------------------------------------------+
| 1997-12-30 22:58:58.999997                              |
+---------------------------------------------------------+
1 row in set (0.00 sec)

SYSDATE ()

Gibt das aktuelle Datum und die aktuelle Uhrzeit als Wert im Format 'JJJJ-MM-TT HH: MM: SS' oder JJJJMMTTHHMMSS zurück, je nachdem, ob die Funktion in einer Zeichenfolge oder in einem numerischen Kontext verwendet wird.

mysql> SELECT SYSDATE();
+---------------------------------------------------------+
| SYSDATE()                                               |
+---------------------------------------------------------+
| 2006-04-12 13:47:44                                     |
+---------------------------------------------------------+
1 row in set (0.00 sec)

ZEIT (Ausdruck)

Extrahiert den Zeitteil des Zeit- oder Datums- / Uhrzeitausdrucks expr und gibt es als Zeichenfolge zurück.

mysql> SELECT TIME('2003-12-31 01:02:03');
+---------------------------------------------------------+
| TIME('2003-12-31 01:02:03')                             |
+---------------------------------------------------------+
| 01:02:03                                                |
+---------------------------------------------------------+
1 row in set (0.00 sec)

TIMEDIFF (Ausdruck1, Ausdruck2)

Die Funktion TIMEDIFF () gibt expr1 zurück. Ausdruck2 ausgedrückt als Zeitwert. Diese expr1- und expr2-Werte sind Zeit- oder Datums- und Zeitausdrücke, aber beide müssen vom gleichen Typ sein.

mysql> SELECT TIMEDIFF('1997-12-31 23:59:59.000001',
   -> '1997-12-30 01:01:01.000002');
+---------------------------------------------------------+
| TIMEDIFF('1997-12-31 23:59:59.000001'.....              |
+---------------------------------------------------------+
|  46:58:57.999999                                        |
+---------------------------------------------------------+
1 row in set (0.00 sec)

TIMESTAMP (Ausdruck), TIMESTAMP (Ausdruck1, Ausdruck2)

Mit einem einzigen Argument gibt diese Funktion den Datums- oder Datums- / Uhrzeitausdruck expr als Datums- / Uhrzeitwert zurück. Mit zwei Argumenten wird der Uhrzeitausdruck expr2 zum Datums- oder Datums- / Uhrzeitausdruck hinzugefügtexpr1 und gibt das Ergebnis als Datum / Uhrzeit-Wert zurück.

mysql> SELECT TIMESTAMP('2003-12-31');
+---------------------------------------------------------+
| TIMESTAMP('2003-12-31')                                 |
+---------------------------------------------------------+
| 2003-12-31 00:00:00                                     |
+---------------------------------------------------------+
1 row in set (0.00 sec)

TIMESTAMPADD (Einheit, Intervall, datetime_expr)

Diese Funktion fügt dem Datums- oder Datums- / Uhrzeitausdruck das Intervall für ganzzahlige Ausdrücke hinzu datetime_expr. Die Einheit für das Intervall wird durch das Einheitsargument angegeben, das einer der folgenden Werte sein sollte:

• FRAC_SECOND
• ZWEITE, MINUTE
• STUNDE, TAG
• WEEK
• MONTH
• QUARTAL oder
• YEAR

Der Einheitswert kann mit einem der gezeigten Schlüsselwörter oder mit dem Präfix SQL_TSI_ angegeben werden.

Zum Beispiel sind DAY und SQL_TSI_DAY beide legal.

mysql> SELECT TIMESTAMPADD(MINUTE,1,'2003-01-02');
+---------------------------------------------------------+
| TIMESTAMPADD(MINUTE,1,'2003-01-02')                     |
+---------------------------------------------------------+
| 2003-01-02 00:01:00                                     |
+---------------------------------------------------------+
1 row in set (0.00 sec)

TIMESTAMPDIFF (Einheit, datetime_expr1, datetime_expr2)

Gibt die ganzzahlige Differenz zwischen den Datums- oder Datums- / Uhrzeitausdrücken datetime_expr1 und datetime_expr2 zurück. Die Einheit für das Ergebnis wird durch das Einheitsargument angegeben. Die zulässigen Werte für das Gerät entsprechen denen, die in der Beschreibung der Funktion TIMESTAMPADD () aufgeführt sind.

mysql> SELECT TIMESTAMPDIFF(MONTH,'2003-02-01','2003-05-01');
+---------------------------------------------------------+
| TIMESTAMPDIFF(MONTH,'2003-02-01','2003-05-01')          |
+---------------------------------------------------------+
| 3                                                       |
+---------------------------------------------------------+
1 row in set (0.00 sec)

TIME_FORMAT (Zeit, Format)

Diese Funktion wird wie die Funktion DATE_FORMAT () verwendet, die Formatzeichenfolge kann jedoch Formatspezifizierer nur für Stunden, Minuten und Sekunden enthalten.

Wenn der Zeitwert einen Stundenanteil enthält, der größer als 23 ist, wird der%H und %k Stundenformatspezifizierer erzeugen einen Wert, der größer als der übliche Bereich von 0 bis 23 ist. Die anderen Stundenformatspezifizierer erzeugen den Stundenwert modulo 12.

mysql> SELECT TIME_FORMAT('100:00:00', '%H %k %h %I %l');
+---------------------------------------------------------+
| TIME_FORMAT('100:00:00', '%H %k %h %I %l')              |
+---------------------------------------------------------+
| 100 100 04 04 4                                         |
+---------------------------------------------------------+
1 row in set (0.00 sec)

TIME_TO_SEC (Zeit)

Gibt das in Sekunden konvertierte Zeitargument zurück.

mysql> SELECT TIME_TO_SEC('22:23:00');
+---------------------------------------------------------+
| TIME_TO_SEC('22:23:00')                                 |
+---------------------------------------------------------+
| 80580                                                   |
+---------------------------------------------------------+
1 row in set (0.00 sec)

Heutiges Datum)

Gibt bei einem bestimmten Datum eine Tagesnummer zurück (die Anzahl der Tage seit dem Jahr 0).

mysql> SELECT TO_DAYS(950501);
+---------------------------------------------------------+
| TO_DAYS(950501)                                         |
+---------------------------------------------------------+
| 728779                                                  |
+---------------------------------------------------------+
1 row in set (0.00 sec)

UNIX_TIMESTAMP (), UNIX_TIMESTAMP (Datum)

Wenn diese Funktion ohne Argument aufgerufen wird, gibt sie einen Unix-Zeitstempel (Sekunden seit '1970-01-01 00:00:00' UTC) als vorzeichenlose Ganzzahl zurück. Wenn UNIX_TIMESTAMP () mit einem Datumsargument aufgerufen wird, wird der Wert des Arguments als Sekunden seit '1970-01-01 00:00:00' UTC zurückgegeben. Datum kann eine DATE-Zeichenfolge, eine DATETIME-Zeichenfolge, ein TIMESTAMP oder eine Zahl im Format JJJMTT oder JJJJMMTT sein.

mysql> SELECT UNIX_TIMESTAMP();
+---------------------------------------------------------+
| UNIX_TIMESTAMP()                                        |
+---------------------------------------------------------+
| 882226357                                               |
+---------------------------------------------------------+
1 row in set (0.00 sec)

mysql> SELECT UNIX_TIMESTAMP('1997-10-04 22:23:00');
+---------------------------------------------------------+
| UNIX_TIMESTAMP('1997-10-04 22:23:00')                   |
+---------------------------------------------------------+
| 875996580                                               |
+---------------------------------------------------------+
1 row in set (0.00 sec)

UTC_DATE, UTC_DATE ()

Gibt das aktuelle UTC-Datum als Wert im Format 'JJJJ-MM-TT' oder JJJJMMTT zurück, je nachdem, ob die Funktion in einer Zeichenfolge oder einem numerischen Kontext verwendet wird.

mysql> SELECT UTC_DATE(), UTC_DATE() + 0;
+---------------------------------------------------------+
| UTC_DATE(), UTC_DATE() + 0                              |
+---------------------------------------------------------+
| 2003-08-14, 20030814                                    |
+---------------------------------------------------------+
1 row in set (0.00 sec)

UTC_TIME, UTC_TIME ()

Gibt die aktuelle UTC-Zeit als Wert im Format 'HH: MM: SS' oder HHMMSS zurück, je nachdem, ob die Funktion in einem String- oder einem numerischen Kontext verwendet wird.

mysql> SELECT UTC_TIME(), UTC_TIME() + 0;
+---------------------------------------------------------+
| UTC_TIME(), UTC_TIME() + 0                              |
+---------------------------------------------------------+
| 18:07:53, 180753                                        |
+---------------------------------------------------------+
1 row in set (0.00 sec)

UTC_TIMESTAMP, UTC_TIMESTAMP ()

Gibt das aktuelle UTC-Datum und die aktuelle UTC-Uhrzeit als Wert in 'JJJJ-MM-TT HH: MM: SS' oder in einem JJJJMMTTHHMMSS-Format zurück, je nachdem, ob die Funktion in einer Zeichenfolge oder in einem numerischen Kontext verwendet wird.

mysql> SELECT UTC_TIMESTAMP(), UTC_TIMESTAMP() + 0;
+---------------------------------------------------------+
| UTC_TIMESTAMP(), UTC_TIMESTAMP() + 0                    |
+---------------------------------------------------------+
| 2003-08-14 18:08:04, 20030814180804                     |
+---------------------------------------------------------+
1 row in set (0.00 sec)

WOCHE (Datum [, Modus])

Diese Funktion gibt die Wochennummer für das Datum zurück. Mit der Zwei-Argument-Form von WEEK () können Sie angeben, ob die Woche an einem Sonntag oder einem Montag beginnt und ob der Rückgabewert im Bereich von 0 bis 53 oder von 1 bis 53 liegen soll. Wenn das Argument mode weggelassen wird, Der Wert der Systemvariablen default_week_format wird verwendet

Modus	Erster Tag der Woche	Angebot	Woche 1 ist die erste Woche.
0	Sonntag	0-53	mit einem Sonntag in diesem Jahr
1	Montag	0-53	mit mehr als 3 Tagen in diesem Jahr
2	Sonntag	1-53	mit einem Sonntag in diesem Jahr
3	Montag	1-53	mit mehr als 3 Tagen in diesem Jahr
4	Sonntag	0-53	mit mehr als 3 Tagen in diesem Jahr
5	Montag	0-53	mit einem Montag in diesem Jahr
6	Sonntag	1-53	mit mehr als 3 Tagen in diesem Jahr
7	Montag	1-53	mit einem Montag in diesem Jahr

mysql> SELECT WEEK('1998-02-20');
+---------------------------------------------------------+
| WEEK('1998-02-20')                                      |
+---------------------------------------------------------+
| 7                                                       |
+---------------------------------------------------------+
1 row in set (0.00 sec)

WOCHENTAG (Datum)

Gibt den Wochentagsindex für das Datum zurück (0 = Montag, 1 = Dienstag ,. 6 = Sonntag).

mysql> SELECT WEEKDAY('1998-02-03 22:23:00');
+---------------------------------------------------------+
| WEEKDAY('1998-02-03 22:23:00')                          |
+---------------------------------------------------------+
| 1                                                       |
+---------------------------------------------------------+
1 row in set (0.00 sec)

WOCHENTAG (Datum)

Gibt die Kalenderwoche des Datums als Zahl im Bereich von 1 bis 53 zurück. WEEKOFYEAR () ist eine Kompatibilitätsfunktion, die WEEK (Datum, 3) entspricht.

mysql> SELECT WEEKOFYEAR('1998-02-20');
+---------------------------------------------------------+
| WEEKOFYEAR('1998-02-20')                                |
+---------------------------------------------------------+
| 8                                                       |
+---------------------------------------------------------+
1 row in set (0.00 sec)

JAHR (Datum)

Gibt das Jahr für das Datum im Bereich von 1000 bis 9999 oder 0 für die Null zurück. Datum.

mysql> SELECT YEAR('98-02-03');
+---------------------------------------------------------+
| YEAR('98-02-03')                                        |
+---------------------------------------------------------+
| 1998                                                    |
+---------------------------------------------------------+
1 row in set (0.00 sec)

YEARWEEK (Datum), YEARWEEK (Datum, Modus)

Gibt das Jahr und die Woche für ein Datum zurück. Das Modusargument funktioniert genau wie das Modusargument für die Funktion WEEK (). Das Jahr im Ergebnis kann sich vom Datum im Datumsargument für die erste und die letzte Woche des Jahres unterscheiden.

mysql> SELECT YEARWEEK('1987-01-01');
+---------------------------------------------------------+
| YEAR('98-02-03')YEARWEEK('1987-01-01')                  |
+---------------------------------------------------------+
| 198653                                                  |
+---------------------------------------------------------+
1 row in set (0.00 sec)

Note - Die Wochennummer unterscheidet sich von der Funktion, die die Funktion WEEK () für optionale Argumente 0 oder 1 zurückgeben würde (0), da WEEK () dann die Woche im Kontext des angegebenen Jahres zurückgibt.

SQL - Temporäre Tabellen

Was sind temporäre Tabellen?

Es gibt RDBMS, die temporäre Tabellen unterstützen. Temporäre Tabellen sind eine großartige Funktion, mit der Siestore and process intermediate results Verwenden Sie dieselben Auswahl-, Aktualisierungs- und Verknüpfungsfunktionen, die Sie für typische SQL Server-Tabellen verwenden können.

Die temporären Tabellen können in einigen Fällen sehr nützlich sein, um temporäre Daten zu speichern. Das Wichtigste, was für temporäre Tabellen bekannt sein sollte, ist, dass sie gelöscht werden, wenn die aktuelle Clientsitzung beendet wird.

Temporäre Tabellen sind ab MySQL Version 3.23 verfügbar. Wenn Sie eine ältere Version von MySQL als 3.23 verwenden, können Sie keine temporären Tabellen verwenden, aber Sie können verwendenheap tables.

Wie bereits erwähnt, halten temporäre Tabellen nur so lange, wie die Sitzung aktiv ist. Wenn Sie den Code in einem PHP-Skript ausführen, wird die temporäre Tabelle automatisch zerstört, wenn die Ausführung des Skripts abgeschlossen ist. Wenn Sie über das MySQL-Client-Programm mit dem MySQL-Datenbankserver verbunden sind, bleibt die temporäre Tabelle bestehen, bis Sie den Client schließen oder die Tabelle manuell zerstören.

Beispiel

Hier ist ein Beispiel, das Ihnen die Verwendung einer temporären Tabelle zeigt.

mysql> CREATE TEMPORARY TABLE SALESSUMMARY (
   -> product_name VARCHAR(50) NOT NULL
   -> , total_sales DECIMAL(12,2) NOT NULL DEFAULT 0.00
   -> , avg_unit_price DECIMAL(7,2) NOT NULL DEFAULT 0.00
   -> , total_units_sold INT UNSIGNED NOT NULL DEFAULT 0
);
Query OK, 0 rows affected (0.00 sec)

mysql> INSERT INTO SALESSUMMARY
   -> (product_name, total_sales, avg_unit_price, total_units_sold)
   -> VALUES
   -> ('cucumber', 100.25, 90, 2);

mysql> SELECT * FROM SALESSUMMARY;
+--------------+-------------+----------------+------------------+
| product_name | total_sales | avg_unit_price | total_units_sold |
+--------------+-------------+----------------+------------------+
| cucumber     |      100.25 |          90.00 |                2 |
+--------------+-------------+----------------+------------------+
1 row in set (0.00 sec)

Wenn Sie einen Befehl SHOW TABLES ausgeben, wird Ihre temporäre Tabelle nicht in der Liste aufgeführt. Wenn Sie sich jetzt von der MySQL-Sitzung abmelden und dann einen SELECT-Befehl ausgeben, sind in der Datenbank keine Daten verfügbar. Auch Ihre temporäre Tabelle ist nicht vorhanden.

Temporäre Tabellen löschen

Standardmäßig werden alle temporären Tabellen von MySQL gelöscht, wenn Ihre Datenbankverbindung beendet wird. Wenn Sie sie jedoch zwischendurch löschen möchten, können Sie dies tun, indem Sie a ausgebenDROP TABLE Befehl.

Es folgt ein Beispiel zum Löschen einer temporären Tabelle.

mysql> CREATE TEMPORARY TABLE SALESSUMMARY (
   -> product_name VARCHAR(50) NOT NULL
   -> , total_sales DECIMAL(12,2) NOT NULL DEFAULT 0.00
   -> , avg_unit_price DECIMAL(7,2) NOT NULL DEFAULT 0.00
   -> , total_units_sold INT UNSIGNED NOT NULL DEFAULT 0
);
Query OK, 0 rows affected (0.00 sec)

mysql> INSERT INTO SALESSUMMARY
   -> (product_name, total_sales, avg_unit_price, total_units_sold)
   -> VALUES
   -> ('cucumber', 100.25, 90, 2);

mysql> SELECT * FROM SALESSUMMARY;
+--------------+-------------+----------------+------------------+
| product_name | total_sales | avg_unit_price | total_units_sold |
+--------------+-------------+----------------+------------------+
| cucumber     |      100.25 |          90.00 |                2 |
+--------------+-------------+----------------+------------------+
1 row in set (0.00 sec)
mysql> DROP TABLE SALESSUMMARY;
mysql>  SELECT * FROM SALESSUMMARY;
ERROR 1146: Table 'TUTORIALS.SALESSUMMARY' doesn't exist

SQL - Klontabellen

Es kann vorkommen, dass Sie eine genaue Kopie einer Tabelle benötigen und die Befehle CREATE TABLE ... oder SELECT ... nicht Ihren Zwecken entsprechen, da die Kopie dieselben Indizes, Standardwerte usw. enthalten muss.

Wenn Sie MySQL RDBMS verwenden, können Sie mit dieser Situation umgehen, indem Sie die folgenden Schritte ausführen:

• Verwenden Sie den Befehl SHOW CREATE TABLE, um eine CREATE TABLE-Anweisung abzurufen, die die Struktur, die Indizes und alle Elemente der Quelltabelle angibt.

• Ändern Sie die Anweisung, um den Tabellennamen in den Namen der Klontabelle zu ändern, und führen Sie die Anweisung aus. Auf diese Weise erhalten Sie eine genaue Klontabelle.

• Wenn Sie auch den Tabelleninhalt kopieren möchten, geben Sie optional auch eine INSERT INTO- oder eine SELECT-Anweisung aus.

Beispiel

Probieren Sie das folgende Beispiel aus, um eine Klontabelle für zu erstellen TUTORIALS_TBL deren Struktur ist wie folgt -

Step 1 - Holen Sie sich die vollständige Struktur über die Tabelle.

SQL> SHOW CREATE TABLE TUTORIALS_TBL \G; 
*************************** 1. row *************************** 
      Table: TUTORIALS_TBL 
Create Table: CREATE TABLE 'TUTORIALS_TBL' ( 
  'tutorial_id' int(11) NOT NULL auto_increment, 
  'tutorial_title' varchar(100) NOT NULL default '', 
  'tutorial_author' varchar(40) NOT NULL default '', 
  'submission_date' date default NULL, 
  PRIMARY KEY  ('tutorial_id'), 
  UNIQUE KEY 'AUTHOR_INDEX' ('tutorial_author') 
) TYPE = MyISAM 
1 row in set (0.00 sec)

Step 2 - Benennen Sie diese Tabelle um und erstellen Sie eine weitere Tabelle.

SQL> CREATE TABLE `CLONE_TBL` ( 
  -> 'tutorial_id' int(11) NOT NULL auto_increment, 
  -> 'tutorial_title' varchar(100) NOT NULL default '', 
  -> 'tutorial_author' varchar(40) NOT NULL default '', 
  -> 'submission_date' date default NULL, 
  -> PRIMARY KEY  (`tutorial_id'), 
  -> UNIQUE KEY 'AUTHOR_INDEX' ('tutorial_author') 
-> ) TYPE = MyISAM; 
Query OK, 0 rows affected (1.80 sec)

Step 3- Nachdem Sie Schritt 2 ausgeführt haben, klonen Sie eine Tabelle in Ihrer Datenbank. Wenn Sie Daten aus einer alten Tabelle kopieren möchten, können Sie dies mit der Anweisung INSERT INTO ... SELECT tun.

SQL> INSERT INTO CLONE_TBL (tutorial_id, 
   ->                        tutorial_title, 
   ->                        tutorial_author, 
   ->                        submission_date) 
   -> SELECT tutorial_id,tutorial_title, 
   ->        tutorial_author,submission_date, 
   -> FROM TUTORIALS_TBL; 
Query OK, 3 rows affected (0.07 sec) 
Records: 3  Duplicates: 0  Warnings: 0

Schließlich haben Sie eine genaue Klontabelle, wie Sie sie haben wollten.

SQL - Unterabfragen

Eine Unterabfrage oder innere Abfrage oder eine verschachtelte Abfrage ist eine Abfrage in einer anderen SQL-Abfrage und eingebettet in die WHERE-Klausel.

Eine Unterabfrage wird verwendet, um Daten zurückzugeben, die in der Hauptabfrage als Bedingung verwendet werden, um die abzurufenden Daten weiter einzuschränken.

Unterabfragen können mit den Anweisungen SELECT, INSERT, UPDATE und DELETE zusammen mit den Operatoren wie =, <,>,> =, <=, IN, ZWISCHEN usw. verwendet werden.

Es gibt einige Regeln, denen Unterabfragen folgen müssen -

• Unterabfragen müssen in Klammern stehen.

• Eine Unterabfrage kann nur eine Spalte in der SELECT-Klausel enthalten, es sei denn, die Hauptabfrage enthält mehrere Spalten, damit die Unterabfrage ihre ausgewählten Spalten vergleicht.

• Ein ORDER BY-Befehl kann nicht in einer Unterabfrage verwendet werden, obwohl die Hauptabfrage einen ORDER BY verwenden kann. Mit dem Befehl GROUP BY kann dieselbe Funktion wie mit dem Befehl ORDER BY in einer Unterabfrage ausgeführt werden.

• Unterabfragen, die mehr als eine Zeile zurückgeben, können nur mit mehreren Wertoperatoren wie dem IN-Operator verwendet werden.

• Die SELECT-Liste darf keine Verweise auf Werte enthalten, die für ein BLOB, ARRAY, CLOB oder NCLOB ausgewertet werden.

• Eine Unterabfrage kann nicht sofort in eine Set-Funktion eingeschlossen werden.

• Der Operator BETWEEN kann nicht mit einer Unterabfrage verwendet werden. Der Operator BETWEEN kann jedoch innerhalb der Unterabfrage verwendet werden.

Unterabfragen mit der SELECT-Anweisung

Unterabfragen werden am häufigsten mit der SELECT-Anweisung verwendet. Die grundlegende Syntax lautet wie folgt:

SELECT column_name [, column_name ]
FROM   table1 [, table2 ]
WHERE  column_name OPERATOR
   (SELECT column_name [, column_name ]
   FROM table1 [, table2 ]
   [WHERE])

Beispiel

Betrachten Sie die Tabelle CUSTOMERS mit den folgenden Datensätzen:

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  35 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Lassen Sie uns nun die folgende Unterabfrage mit einer SELECT-Anweisung überprüfen.

SQL> SELECT * 
   FROM CUSTOMERS 
   WHERE ID IN (SELECT ID 
         FROM CUSTOMERS 
         WHERE SALARY > 4500) ;

Dies würde das folgende Ergebnis erzeugen.

+----+----------+-----+---------+----------+
| ID | NAME     | AGE | ADDRESS | SALARY   |
+----+----------+-----+---------+----------+
|  4 | Chaitali |  25 | Mumbai  |  6500.00 |
|  5 | Hardik   |  27 | Bhopal  |  8500.00 |
|  7 | Muffy    |  24 | Indore  | 10000.00 |
+----+----------+-----+---------+----------+

Unterabfragen mit der INSERT-Anweisung

Unterabfragen können auch mit INSERT-Anweisungen verwendet werden. Die INSERT-Anweisung verwendet die von der Unterabfrage zurückgegebenen Daten, um sie in eine andere Tabelle einzufügen. Die ausgewählten Daten in der Unterabfrage können mit einer beliebigen Zeichen-, Datums- oder Zahlenfunktion geändert werden.

Die grundlegende Syntax lautet wie folgt.

INSERT INTO table_name [ (column1 [, column2 ]) ]
   SELECT [ *|column1 [, column2 ]
   FROM table1 [, table2 ]
   [ WHERE VALUE OPERATOR ]

Beispiel

Stellen Sie sich eine Tabelle CUSTOMERS_BKP mit einer ähnlichen Struktur wie die Tabelle CUSTOMERS vor. Um nun die vollständige CUSTOMERS-Tabelle in die CUSTOMERS_BKP-Tabelle zu kopieren, können Sie die folgende Syntax verwenden.

SQL> INSERT INTO CUSTOMERS_BKP
   SELECT * FROM CUSTOMERS 
   WHERE ID IN (SELECT ID 
   FROM CUSTOMERS) ;

Unterabfragen mit der UPDATE-Anweisung

Die Unterabfrage kann in Verbindung mit der UPDATE-Anweisung verwendet werden. Bei Verwendung einer Unterabfrage mit der UPDATE-Anweisung können entweder einzelne oder mehrere Spalten in einer Tabelle aktualisiert werden.

Die grundlegende Syntax lautet wie folgt.

UPDATE table
SET column_name = new_value
[ WHERE OPERATOR [ VALUE ]
   (SELECT COLUMN_NAME
   FROM TABLE_NAME)
   [ WHERE) ]

Beispiel

Angenommen, wir haben die Tabelle CUSTOMERS_BKP zur Verfügung, die eine Sicherung der Tabelle CUSTOMERS darstellt. Im folgenden Beispiel wird das GEHALT in der Tabelle KUNDEN für alle Kunden, deren ALTER größer oder gleich 27 ist, um das 0,25-fache aktualisiert.

SQL> UPDATE CUSTOMERS
   SET SALARY = SALARY * 0.25
   WHERE AGE IN (SELECT AGE FROM CUSTOMERS_BKP
      WHERE AGE >= 27 );

Dies würde sich auf zwei Zeilen auswirken und schließlich würde die Tabelle CUSTOMERS die folgenden Datensätze enthalten.

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  35 | Ahmedabad |   125.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  2125.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Unterabfragen mit der DELETE-Anweisung

Die Unterabfrage kann wie alle anderen oben genannten Anweisungen in Verbindung mit der Anweisung DELETE verwendet werden.

Die grundlegende Syntax lautet wie folgt.

DELETE FROM TABLE_NAME
[ WHERE OPERATOR [ VALUE ]
   (SELECT COLUMN_NAME
   FROM TABLE_NAME)
   [ WHERE) ]

Beispiel

Angenommen, wir haben eine Tabelle CUSTOMERS_BKP zur Verfügung, die eine Sicherung der Tabelle CUSTOMERS darstellt. Im folgenden Beispiel werden die Datensätze aus der Tabelle CUSTOMERS für alle Kunden gelöscht, deren AGE größer oder gleich 27 ist.

SQL> DELETE FROM CUSTOMERS
   WHERE AGE IN (SELECT AGE FROM CUSTOMERS_BKP
      WHERE AGE >= 27 );

Dies würde sich auf zwei Zeilen auswirken und schließlich würde die Tabelle CUSTOMERS die folgenden Datensätze enthalten.

+----+----------+-----+---------+----------+
| ID | NAME     | AGE | ADDRESS | SALARY   |
+----+----------+-----+---------+----------+
|  2 | Khilan   |  25 | Delhi   |  1500.00 |
|  3 | kaushik  |  23 | Kota    |  2000.00 |
|  4 | Chaitali |  25 | Mumbai  |  6500.00 |
|  6 | Komal    |  22 | MP      |  4500.00 |
|  7 | Muffy    |  24 | Indore  | 10000.00 |
+----+----------+-----+---------+----------+

SQL - Verwenden von Sequenzen

Eine Sequenz ist eine Menge von Ganzzahlen 1, 2, 3, ..., die bei Bedarf in der richtigen Reihenfolge generiert werden. Sequenzen werden häufig in Datenbanken verwendet, da bei vielen Anwendungen jede Zeile in einer Tabelle einen eindeutigen Wert enthalten muss und Sequenzen eine einfache Möglichkeit bieten, sie zu generieren.

In diesem Kapitel wird die Verwendung von Sequenzen in MySQL beschrieben.

Verwenden der Spalte AUTO_INCREMENT

Die einfachste Möglichkeit in MySQL, Sequenzen zu verwenden, besteht darin, eine Spalte als AUTO_INCREMENT zu definieren und den Rest MySQL zu überlassen.

Beispiel

Probieren Sie das folgende Beispiel aus. Dadurch wird eine Tabelle erstellt und anschließend werden einige Zeilen in diese Tabelle eingefügt, in denen keine Datensatz-ID angegeben werden muss, da diese von MySQL automatisch erhöht wird.

mysql> CREATE TABLE INSECT
   -> (
   -> id INT UNSIGNED NOT NULL AUTO_INCREMENT,
   -> PRIMARY KEY (id),
   -> name VARCHAR(30) NOT NULL, # type of insect
   -> date DATE NOT NULL, # date collected
   -> origin VARCHAR(30) NOT NULL # where collected
);
Query OK, 0 rows affected (0.02 sec)
mysql> INSERT INTO INSECT (id,name,date,origin) VALUES
   -> (NULL,'housefly','2001-09-10','kitchen'),
   -> (NULL,'millipede','2001-09-10','driveway'),
   -> (NULL,'grasshopper','2001-09-10','front yard');
Query OK, 3 rows affected (0.02 sec)
Records: 3  Duplicates: 0  Warnings: 0
mysql> SELECT * FROM INSECT ORDER BY id;
+----+-------------+------------+------------+
| id | name        | date       | origin     |
+----+-------------+------------+------------+
|  1 | housefly    | 2001-09-10 | kitchen    |
|  2 | millipede   | 2001-09-10 | driveway   |
|  3 | grasshopper | 2001-09-10 | front yard |
+----+-------------+------------+------------+
3 rows in set (0.00 sec)

Erhalten Sie AUTO_INCREMENT-Werte

Die LAST_INSERT_ID () ist eine SQL-Funktion, sodass Sie sie von jedem Client aus verwenden können, der versteht, wie SQL-Anweisungen ausgegeben werden. Andernfalls bieten PERL- und PHP-Skripte exklusive Funktionen zum Abrufen des automatisch inkrementierten Werts des letzten Datensatzes.

PERL Beispiel

Verwenden Sie die mysql_insertidAttribut, um den von einer Abfrage generierten Wert AUTO_INCREMENT zu erhalten. Der Zugriff auf dieses Attribut erfolgt entweder über ein Datenbankhandle oder ein Anweisungshandle, je nachdem, wie Sie die Abfrage ausgeben. Das folgende Beispiel verweist darauf über das Datenbankhandle.

$dbh->do ("INSERT INTO INSECT (name,date,origin) VALUES('moth','2001-09-14','windowsill')"); my $seq = $dbh->{mysql_insertid};

PHP Beispiel

Rufen Sie nach dem Ausgeben einer Abfrage, die einen AUTO_INCREMENT-Wert generiert, den Wert durch Aufrufen von ab mysql_insert_id( ) Funktion.

mysql_query ("INSERT INTO INSECT (name,date,origin)
VALUES('moth','2001-09-14','windowsill')", $conn_id);
$seq = mysql_insert_id ($conn_id);

Bestehende Sequenz neu nummerieren

Es kann vorkommen, dass Sie viele Datensätze aus einer Tabelle gelöscht haben und alle Datensätze neu sortieren möchten. Dies kann mit einem einfachen Trick geschehen. Sie sollten jedoch sehr vorsichtig sein und prüfen, ob Ihre Tabelle mit einer anderen Tabelle verknüpft ist oder nicht.

Wenn Sie feststellen, dass eine erneute Sequenzierung einer AUTO_INCREMENT-Spalte unvermeidbar ist, löschen Sie die Spalte aus der Tabelle und fügen Sie sie erneut hinzu.

Das folgende Beispiel zeigt, wie Sie die ID-Werte in der Insektentabelle mit dieser Technik neu nummerieren.

mysql> ALTER TABLE INSECT DROP id;
mysql> ALTER TABLE insect
   -> ADD id INT UNSIGNED NOT NULL AUTO_INCREMENT FIRST,
   -> ADD PRIMARY KEY (id);

Starten einer Sequenz bei einem bestimmten Wert

Standardmäßig startet MySQL die Sequenz mit 1, Sie können jedoch zum Zeitpunkt der Tabellenerstellung auch eine andere Nummer angeben.

Der folgende Codeblock enthält ein Beispiel, in dem MySQL die Sequenz ab 100 startet.

mysql> CREATE TABLE INSECT
   -> (
   -> id INT UNSIGNED NOT NULL AUTO_INCREMENT = 100,
   -> PRIMARY KEY (id),
   -> name VARCHAR(30) NOT NULL, # type of insect
   -> date DATE NOT NULL, # date collected
   -> origin VARCHAR(30) NOT NULL # where collected
);

Alternativ können Sie die Tabelle erstellen und dann mit ALTER TABLE den anfänglichen Sequenzwert festlegen.

mysql> ALTER TABLE t AUTO_INCREMENT = 100;

SQL - Umgang mit Duplikaten

Es kann vorkommen, dass eine Tabelle mehrere doppelte Datensätze enthält. Beim Abrufen solcher Datensätze ist es sinnvoller, nur eindeutige Datensätze abzurufen, anstatt doppelte Datensätze abzurufen.

Die SQL DISTINCT Das Schlüsselwort, das wir bereits besprochen haben, wird in Verbindung mit der SELECT-Anweisung verwendet, um alle doppelten Datensätze zu entfernen und nur die eindeutigen Datensätze abzurufen.

Syntax

Die grundlegende Syntax eines DISTINCT-Schlüsselworts zum Entfernen doppelter Datensätze lautet wie folgt.

SELECT DISTINCT column1, column2,.....columnN 
FROM table_name
WHERE [condition]

Beispiel

Betrachten Sie die Tabelle CUSTOMERS mit den folgenden Datensätzen.

+----+----------+-----+-----------+----------+
| ID | NAME     | AGE | ADDRESS   | SALARY   |
+----+----------+-----+-----------+----------+
|  1 | Ramesh   |  32 | Ahmedabad |  2000.00 |
|  2 | Khilan   |  25 | Delhi     |  1500.00 |
|  3 | kaushik  |  23 | Kota      |  2000.00 |
|  4 | Chaitali |  25 | Mumbai    |  6500.00 |
|  5 | Hardik   |  27 | Bhopal    |  8500.00 |
|  6 | Komal    |  22 | MP        |  4500.00 |
|  7 | Muffy    |  24 | Indore    | 10000.00 |
+----+----------+-----+-----------+----------+

Lassen Sie uns zunächst sehen, wie die folgende SELECT-Abfrage doppelte Gehaltsdatensätze zurückgibt.

SQL> SELECT SALARY FROM CUSTOMERS
   ORDER BY SALARY;

Dies würde das folgende Ergebnis ergeben, wenn das Gehalt von 2000 zweimal kommt, was ein doppelter Datensatz aus der ursprünglichen Tabelle ist.

+----------+
| SALARY   |
+----------+
|  1500.00 |
|  2000.00 |
|  2000.00 |
|  4500.00 |
|  6500.00 |
|  8500.00 |
| 10000.00 |
+----------+

Verwenden wir nun das Schlüsselwort DISTINCT mit der obigen SELECT-Abfrage und sehen das Ergebnis.

SQL> SELECT DISTINCT SALARY FROM CUSTOMERS
   ORDER BY SALARY;

Dies würde das folgende Ergebnis ergeben, wenn wir keinen doppelten Eintrag haben.

+----------+
| SALARY   |
+----------+
|  1500.00 |
|  2000.00 |
|  4500.00 |
|  6500.00 |
|  8500.00 |
| 10000.00 |
+----------+

SQL-Injektion

Wenn Sie eine Benutzereingabe über eine Webseite in eine SQL-Datenbank einfügen, besteht die Möglichkeit, dass Sie sich für ein Sicherheitsproblem, das als bekannt ist, weit offen gelassen haben SQL Injection. In diesem Kapitel erfahren Sie, wie Sie dies verhindern und Ihre Skripte und SQL-Anweisungen in serverseitigen Skripten wie einem PERL-Skript sichern können.

Die Injektion erfolgt normalerweise, wenn Sie einen Benutzer nach einer Eingabe wie seinem Namen fragen und anstelle eines Namens eine SQL-Anweisung erhalten, die Sie unwissentlich in Ihrer Datenbank ausführen. Vertrauen Sie niemals vom Benutzer bereitgestellten Daten. Verarbeiten Sie diese Daten erst nach der Validierung. Dies geschieht in der Regel durchPattern Matching.

Im folgenden Beispiel wird die name ist auf die alphanumerischen Zeichen plus Unterstrich und auf eine Länge zwischen 8 und 20 Zeichen beschränkt (ändern Sie diese Regeln nach Bedarf).

if (preg_match("/^\w{8,20}$/", $_GET['username'], $matches)) { $result = mysql_query("SELECT * FROM CUSTOMERS 
      WHERE name = $matches[0]");
} else {
   echo "user name not accepted";
}

Betrachten Sie diesen Auszug, um das Problem zu demonstrieren -

// supposed input
$name = "Qadir'; DELETE FROM CUSTOMERS;";
mysql_query("SELECT * FROM CUSTOMSRS WHERE name='{$name}'");

Der Funktionsaufruf soll einen Datensatz aus der Tabelle CUSTOMERS abrufen, wobei die Namensspalte mit dem vom Benutzer angegebenen Namen übereinstimmt. Unter normalen Umständen,$namewürde nur alphanumerische Zeichen und möglicherweise Leerzeichen enthalten, wie z. B. die Zeichenfolge ilia. Wenn Sie jedoch eine völlig neue Abfrage an $ name anhängen, wird der Aufruf der Datenbank zu einer Katastrophe. Die injizierte DELETE-Abfrage entfernt alle Datensätze aus der CUSTOMERS-Tabelle.

Glücklicherweise, wenn Sie MySQL verwenden, ist die mysql_query()Die Funktion erlaubt nicht das Stapeln von Abfragen oder das Ausführen mehrerer SQL-Abfragen in einem einzigen Funktionsaufruf. Wenn Sie versuchen, Abfragen zu stapeln, schlägt der Aufruf fehl.

Andere PHP-Datenbankerweiterungen wie z SQLite und PostgreSQL Führen Sie problemlos gestapelte Abfragen durch, führen Sie alle in einer Zeichenfolge bereitgestellten Abfragen aus und verursachen Sie ein ernstes Sicherheitsproblem.

Verhindern von SQL Injection

Sie können alle Escape-Zeichen in Skriptsprachen wie PERL und PHP intelligent verarbeiten. Die MySQL-Erweiterung für PHP bietet die Funktionmysql_real_escape_string() um Eingabezeichen zu umgehen, die für MySQL speziell sind.

if (get_magic_quotes_gpc()) {
   $name = stripslashes($name); } $name = mysql_real_escape_string($name); mysql_query("SELECT * FROM CUSTOMERS WHERE name='{$name}'");

Das ähnliche Dilemma

Um das LIKE-Problem zu lösen, muss ein benutzerdefinierter Escape-Mechanismus vom Benutzer bereitgestellte Zeichen '%' und '_' in Literale konvertieren. Verwendenaddcslashes(), eine Funktion, mit der Sie einen Zeichenbereich angeben können, der maskiert werden soll.

$sub = addcslashes(mysql_real_escape_string("%str"), "%_"); // $sub == \%str\_
mysql_query("SELECT * FROM messages 
   WHERE subject LIKE '{$sub}%'");

SQL - Datenbank-Tunning

Es braucht Zeit, um ein Datenbankexperte oder ein erfahrener Datenbankadministrator zu werden. Dies alles beinhaltet viel Erfahrung in verschiedenen Datenbankdesigns und gute Schulungen.

Die folgende Liste kann jedoch für Anfänger hilfreich sein, um eine gute Datenbankleistung zu erzielen:

• Verwenden Sie das 3BNF-Datenbankdesign, das in diesem Lernprogramm im Kapitel RDBMS-Konzepte erläutert wird.

• Vermeiden Sie die Konvertierung von Zahlen in Zeichen, da Zahlen und Zeichen unterschiedlich verglichen werden und zu einer Leistungsminderung führen.

• Rufen Sie bei Verwendung der SELECT-Anweisung nur die erforderlichen Informationen ab und vermeiden Sie die Verwendung von * in Ihren SELECT-Abfragen, da dies das System unnötig laden würde.

• Erstellen Sie Ihre Indizes sorgfältig für alle Tabellen, in denen Sie häufig suchen. Vermeiden Sie den Index für Tabellen, in denen weniger Suchvorgänge und mehr Einfüge- und Aktualisierungsvorgänge ausgeführt werden.

• Ein vollständiger Tabellenscan wird durchgeführt, wenn den Spalten in der WHERE-Klausel kein Index zugeordnet ist. Sie können einen vollständigen Tabellenscan vermeiden, indem Sie einen Index für Spalten erstellen, die als Bedingungen in der WHERE-Klausel einer SQL-Anweisung verwendet werden.

• Seien Sie sehr vorsichtig mit Gleichheitsoperatoren mit reellen Zahlen und Datums- / Zeitwerten. Beide können kleine Unterschiede aufweisen, die für das Auge nicht offensichtlich sind, aber eine genaue Übereinstimmung unmöglich machen, wodurch verhindert wird, dass Ihre Abfragen jemals Zeilen zurückgeben.

• Verwenden Sie den Mustervergleich mit Bedacht. LIKE COL% ist eine gültige WHERE-Bedingung, die den zurückgegebenen Satz nur auf die Datensätze reduziert, deren Daten mit der Zeichenfolge COL beginnen. COL% Y reduziert jedoch die zurückgegebenen Ergebnisse nicht weiter, da% Y nicht effektiv bewertet werden kann. Der Aufwand für die Bewertung ist zu groß, um berücksichtigt zu werden. In diesem Fall wird COL% verwendet,% Y wird jedoch weggeworfen. Aus dem gleichen Grund verhindert ein führender Platzhalter% COL effektiv, dass der gesamte Filter verwendet wird.

• Optimieren Sie Ihre SQL-Abfragen anhand der Struktur der Abfragen (und Unterabfragen) und der SQL-Syntax, um festzustellen, ob Sie Ihre Tabellen so konzipiert haben, dass sie eine schnelle Datenmanipulation unterstützen, und schreiben Sie die Abfrage optimal, damit Ihr DBMS die Daten effizient bearbeiten kann .

• Versuchen Sie bei Abfragen, die regelmäßig ausgeführt werden, Prozeduren zu verwenden. Eine Prozedur ist eine potenziell große Gruppe von SQL-Anweisungen. Prozeduren werden vom Datenbankmodul kompiliert und dann ausgeführt. Im Gegensatz zu einer SQL-Anweisung muss das Datenbankmodul die Prozedur nicht optimieren, bevor sie ausgeführt wird.

• Vermeiden Sie nach Möglichkeit die Verwendung des logischen Operators ODER in einer Abfrage. ODER verlangsamt unweigerlich fast jede Abfrage für eine Tabelle von beträchtlicher Größe.

• Sie können das Laden von Massendaten optimieren, indem Sie Indizes löschen. Stellen Sie sich die Verlaufstabelle mit vielen tausend Zeilen vor. Diese Verlaufstabelle enthält wahrscheinlich auch einen oder mehrere Indizes. Wenn Sie an einen Index denken, denken Sie normalerweise an einen schnelleren Tabellenzugriff. Bei Batch-Ladevorgängen können Sie jedoch davon profitieren, wenn Sie die Indizes löschen.

• Führen Sie bei der Ausführung von Batch-Transaktionen COMMIT nach einer angemessenen Anzahl von Datensatzerstellungen durch, anstatt sie nach jeder Datensatzerstellung zu erstellen.

• Planen Sie eine regelmäßige Defragmentierung der Datenbank, auch wenn dies die Entwicklung einer wöchentlichen Routine bedeutet.

Eingebaute Tuning-Tools

Oracle verfügt über viele Tools zum Verwalten der Leistung von SQL-Anweisungen, von denen jedoch zwei sehr beliebt sind. Diese beiden Werkzeuge sind -

• Explain plan - Das Tool identifiziert den Zugriffspfad, der bei der Ausführung der SQL-Anweisung verwendet wird.

• tkprof - misst die Leistung anhand der Zeit, die in jeder Phase der Verarbeitung von SQL-Anweisungen verstrichen ist.

Wenn Sie einfach die verstrichene Zeit einer Abfrage in Oracle messen möchten, können Sie den SQL * Plus-Befehl SET TIMING ON verwenden.

Weitere Informationen zu den oben genannten Tools und zur Defragmentierung der Datenbank finden Sie in Ihrer RDBMS-Dokumentation.