SQL-퀵 가이드
SQL은 데이터베이스를 운영하는 언어입니다. 여기에는 데이터베이스 생성, 삭제, 행 가져 오기, 행 수정 등이 포함됩니다. SQL은ANSI (American National Standards Institute) 표준 언어이지만 SQL 언어에는 여러 버전이 있습니다.
SQL이란 무엇입니까?
SQL은 관계형 데이터베이스에 저장된 데이터를 저장, 조작 및 검색하기위한 컴퓨터 언어 인 Structured Query Language입니다.
SQL은 관계형 데이터베이스 시스템의 표준 언어입니다. MySQL, MS Access, Oracle, Sybase, Informix, Postgres 및 SQL Server와 같은 모든 RDMS (관계형 데이터베이스 관리 시스템)는 SQL을 표준 데이터베이스 언어로 사용합니다.
또한 그들은 다음과 같은 다른 방언을 사용하고 있습니다.
- T-SQL을 사용하는 MS SQL Server,
- PL / SQL을 사용하는 Oracle,
- SQL의 MS Access 버전을 JET SQL (네이티브 형식) 등이라고합니다.
왜 SQL인가?
SQL은 다음과 같은 장점을 제공하기 때문에 널리 사용됩니다.
사용자가 관계형 데이터베이스 관리 시스템의 데이터에 액세스 할 수 있습니다.
사용자가 데이터를 설명 할 수 있습니다.
사용자가 데이터베이스의 데이터를 정의하고 해당 데이터를 조작 할 수 있습니다.
SQL 모듈, 라이브러리 및 사전 컴파일러를 사용하여 다른 언어에 임베드 할 수 있습니다.
사용자가 데이터베이스와 테이블을 만들고 삭제할 수 있습니다.
사용자가 데이터베이스에서보기, 저장 프로 시저, 함수를 만들 수 있습니다.
사용자가 테이블, 프로 시저 및보기에 대한 권한을 설정할 수 있습니다.
SQL의 간략한 역사
1970− IBM의 Edgar F. "Ted"Codd 박사는 관계형 데이터베이스의 아버지로 알려져 있습니다. 그는 데이터베이스에 대한 관계형 모델을 설명했습니다.
1974 − Structured Query Language가 나타납니다.
1978 − IBM은 Codd의 아이디어를 개발하고 System / R이라는 제품을 출시했습니다.
1986− IBM은 관계형 데이터베이스의 최초 프로토 타입을 개발하고 ANSI에 의해 표준화되었습니다. 최초의 관계형 데이터베이스는 나중에 Oracle로 알려진 관계형 소프트웨어에 의해 출시되었습니다.
SQL 프로세스
RDBMS에 대해 SQL 명령을 실행할 때 시스템은 요청을 수행하는 가장 좋은 방법을 결정하고 SQL 엔진은 작업을 해석하는 방법을 파악합니다.
이 프로세스에는 다양한 구성 요소가 포함됩니다.
이러한 구성 요소는-
- 쿼리 디스패처
- 최적화 엔진
- 클래식 쿼리 엔진
- SQL 쿼리 엔진 등
클래식 쿼리 엔진은 모든 비 SQL 쿼리를 처리하지만 SQL 쿼리 엔진은 논리 파일을 처리하지 않습니다.
다음은 SQL 아키텍처를 보여주는 간단한 다이어그램입니다.
SQL 명령
관계형 데이터베이스와 상호 작용하는 표준 SQL 명령은 CREATE, SELECT, INSERT, UPDATE, DELETE 및 DROP입니다. 이러한 명령은 특성에 따라 다음 그룹으로 분류 할 수 있습니다.
DDL-데이터 정의 언어
| Sr. 아니. | 명령 및 설명 |
|---|---|
| 1 | CREATE 새 테이블, 테이블보기 또는 데이터베이스의 다른 개체를 만듭니다. |
| 2 | ALTER 테이블과 같은 기존 데이터베이스 개체를 수정합니다. |
| 삼 | DROP 전체 테이블, 테이블보기 또는 데이터베이스의 다른 개체를 삭제합니다. |
DML-데이터 조작 언어
| Sr. 아니. | 명령 및 설명 |
|---|---|
| 1 | SELECT 하나 이상의 테이블에서 특정 레코드를 검색합니다. |
| 2 | INSERT 레코드를 만듭니다. |
| 삼 | UPDATE 레코드를 수정합니다. |
| 4 | DELETE 레코드를 삭제합니다. |
DCL-데이터 제어 언어
| Sr. 아니. | 명령 및 설명 |
|---|---|
| 1 | GRANT 사용자에게 권한을 부여합니다. |
| 2 | REVOKE 사용자가 부여한 권한을 되돌립니다. |
RDBMS 란 무엇입니까?
RDBMS는 R기분 좋은 Database Management System. RDBMS는 SQL 및 MS SQL Server, IBM DB2, Oracle, MySQL 및 Microsoft Access와 같은 모든 최신 데이터베이스 시스템의 기반입니다.
관계형 데이터베이스 관리 시스템 (RDBMS)은 EF Codd가 도입 한 관계형 모델을 기반으로하는 데이터베이스 관리 시스템 (DBMS)입니다.
테이블이란?
RDBMS의 데이터는 다음과 같이 호출되는 데이터베이스 개체에 저장됩니다. tables. 이 테이블은 기본적으로 관련 데이터 항목의 모음이며 수많은 열과 행으로 구성됩니다.
테이블은 관계형 데이터베이스에서 가장 일반적이고 간단한 데이터 저장 형식입니다. 다음 프로그램은 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 |
+----+----------+-----+-----------+----------+필드는 무엇입니까?
모든 테이블은 필드라는 더 작은 항목으로 나뉩니다. CUSTOMERS 테이블의 필드는 ID, NAME, AGE, ADDRESS 및 SALARY로 구성됩니다.
필드는 테이블의 모든 레코드에 대한 특정 정보를 유지하도록 설계된 테이블의 열입니다.
레코드 또는 행이란 무엇입니까?
레코드는 테이블에 존재하는 각 개별 항목 인 데이터 행이라고도합니다. 예를 들어 위의 CUSTOMERS 테이블에는 7 개의 레코드가 있습니다. 다음은 CUSTOMERS 테이블의 데이터 또는 레코드의 단일 행입니다.
+----+----------+-----+-----------+----------+
| 1 | Ramesh | 32 | Ahmedabad | 2000.00 |
+----+----------+-----+-----------+----------+레코드는 테이블의 수평 엔티티입니다.
컬럼이란 무엇입니까?
열은 테이블의 특정 필드와 관련된 모든 정보를 포함하는 테이블의 수직 엔터티입니다.
예를 들어, CUSTOMERS 테이블의 열은 위치 설명을 나타내는 ADDRESS이며 다음과 같습니다.
+-----------+
| ADDRESS |
+-----------+
| Ahmedabad |
| Delhi |
| Kota |
| Mumbai |
| Bhopal |
| MP |
| Indore |
+----+------+NULL 값이란 무엇입니까?
테이블의 NULL 값은 비어있는 것처럼 보이는 필드의 값입니다. 즉, NULL 값이있는 필드는 값이없는 필드입니다.
NULL 값은 0 값 또는 공백이 포함 된 필드와 다르다는 것을 이해하는 것이 매우 중요합니다. NULL 값이있는 필드는 레코드 생성 중에 비어있는 필드입니다.
SQL 제약
제약 조건은 테이블의 데이터 열에 적용되는 규칙입니다. 테이블에 들어갈 수있는 데이터 유형을 제한하는 데 사용됩니다. 이것은 데이터베이스에있는 데이터의 정확성과 신뢰성을 보장합니다.
제약 조건은 열 수준 또는 테이블 수준 일 수 있습니다. 열 수준 제약 조건은 하나의 열에 만 적용되는 반면 테이블 수준 제약 조건은 전체 테이블에 적용됩니다.
다음은 SQL에서 가장 일반적으로 사용되는 제약 조건 중 일부입니다-
NOT NULL Constraint- 열이 NULL 값을 가질 수 없도록합니다.
DEFAULT Constraint- 아무것도 지정되지 않은 경우 열에 대한 기본값을 제공합니다.
UNIQUE Constraint- 열의 모든 값이 다른지 확인합니다.
PRIMARY Key- 데이터베이스 테이블의 각 행 / 레코드를 고유하게 식별합니다.
FOREIGN Key- 고유하게 다른 데이터베이스 테이블에서 행 / 레코드를 식별합니다.
CHECK 제약 조건 -CHECK 제약 조건은 열의 모든 값이 특정 조건을 충족하는지 확인합니다.
INDEX- 매우 빠르게 데이터베이스에서 데이터를 생성하고 검색하는 데 사용됩니다.
데이터 무결성
다음 범주의 데이터 무결성은 각 RDBMS에 존재합니다-
Entity Integrity − 테이블에 중복 행이 없습니다.
Domain Integrity − 유형, 형식 또는 값 범위를 제한하여 주어진 열에 유효한 항목을 적용합니다.
Referential integrity − 다른 레코드에서 사용하는 행은 삭제할 수 없습니다.
User-Defined Integrity − 엔티티, 도메인 또는 참조 무결성에 속하지 않는 일부 특정 비즈니스 규칙을 시행합니다.
데이터베이스 정규화
데이터베이스 정규화는 데이터베이스에서 데이터를 효율적으로 구성하는 프로세스입니다. 이 정규화 과정에는 두 가지 이유가 있습니다.
중복 데이터 제거 (예 : 둘 이상의 테이블에 동일한 데이터 저장)
데이터 종속성을 보장합니다.
이 두 가지 이유는 데이터베이스가 사용하는 공간을 줄이고 데이터가 논리적으로 저장되도록 보장하기 때문에 가치있는 목표입니다. 정규화는 좋은 데이터베이스 구조를 만드는 데 도움이되는 일련의 지침으로 구성됩니다.
정규화 지침은 정규 형식으로 나뉩니다. 형식을 형식 또는 데이터베이스 구조가 배치되는 방식으로 생각하십시오. 정규형의 목적은 데이터베이스 구조를 구성하여 첫 번째 정규형, 두 번째 정규형, 마지막으로 세 번째 정규형의 규칙을 준수하도록하는 것입니다.
더 나아가 네 번째 정규형, 다섯 번째 정규형 등으로 이동하는 것은 당신의 선택이지만 일반적으로 세 번째 정규형은 충분합니다.
- 첫 번째 정규형 (1NF)
- 두 번째 정규형 (2NF)
- 세 번째 정규형 (3NF)
작업 할 수있는 인기있는 RDBMS가 많이 있습니다. 이 튜토리얼에서는 가장 인기있는 RDBMS에 대한 간략한 개요를 제공합니다. 이것은 기본 기능을 비교하는 데 도움이 될 것입니다.
MySQL
MySQL은 스웨덴 회사 인 MySQL AB에서 개발 한 오픈 소스 SQL 데이터베이스입니다. MySQL은 "sequel"로 발음되는 SQL과 달리 "my ess-que-ell"로 발음됩니다.
MySQL은 Microsoft Windows, 주요 Linux 배포판, UNIX 및 Mac OS X를 포함한 다양한 플랫폼을 지원합니다.
MySQL은 사용 (비영리 / 상업용) 및 기능에 따라 무료 및 유료 버전이 있습니다. MySQL은 매우 빠르고 다중 스레드, 다중 사용자 및 강력한 SQL 데이터베이스 서버와 함께 제공됩니다.
역사
1994 년에 Michael Widenius와 David Axmark가 MySQL을 개발했습니다.
23 첫 내부 릴리스 번째 1995년 5월.
윈도우 버전은 8 일에 릴리스되었습니다 번째 Windows 95 및 NT 년 1 월. 1998
버전 3.23 : 2000 년 6 월 베타 버전, 2001 년 1 월 출시.
버전 4.0 : 2002 년 8 월 베타 버전, 2003 년 3 월 프로덕션 릴리스 (unions).
버전 4.1 : 2004 년 6 월 베타 버전, 2004 년 10 월 프로덕션 출시.
버전 5.0 : 2005 년 3 월 베타 버전, 2005 년 10 월 프로덕션 릴리스.
썬 마이크로 시스템즈는 26에서 MySQL AB를 인수 번째 2008년 2월.
버전 5.1 : 생산 릴리스 27 일 2008년 11월.
풍모
- 고성능.
- 고 가용성.
- 확장 성 및 유연성 무엇이든 실행하십시오.
- 강력한 트랜잭션 지원.
- 웹 및 데이터웨어 하우스 강점.
- 강력한 데이터 보호.
- 포괄적 인 애플리케이션 개발.
- 관리 용이성.
- 오픈 소스 자유 및 연중 무휴 지원.
- 최저 총 소유 비용.
MS SQL 서버
MS SQL Server는 Microsoft Inc.에서 개발 한 관계형 데이터베이스 관리 시스템입니다. 주요 쿼리 언어는 다음과 같습니다.
- T-SQL
- ANSI SQL
역사
1987-Sybase가 UNIX 용 SQL Server를 출시합니다.
1988-Microsoft, Sybase 및 Aston-Tate는 SQL Server를 OS / 2로 포팅합니다.
1989-Microsoft, Sybase 및 Aston-Tate가 OS / 2 용 SQL Server 1.0을 출시했습니다.
1990-Windows 3.0 클라이언트를 지원하는 SQL Server 1.1이 출시되었습니다.
Aston-Tate는 SQL Server 개발을 중단합니다.
2000-Microsoft는 SQL Server 2000을 출시합니다.
2001-Microsoft는 SQL Server 웹 릴리스 1 용 XML을 릴리스합니다 (다운로드).
2002-Microsoft에서 SQLXML 2.0 (SQL Server 용 XML에서 이름이 변경됨)을 출시했습니다.
2002-Microsoft에서 SQLXML 3.0을 출시합니다.
2005-Microsoft는 2005 년 11 월 7 일에 SQL Server 2005를 출시합니다.
풍모
- 고성능
- 고 가용성
- 데이터베이스 미러링
- 데이터베이스 스냅 샷
- CLR 통합
- 서비스 브로커
- DDL 트리거
- 순위 기능
- 행 버전 기반 격리 수준
- XML 통합
- TRY...CATCH
- 데이터베이스 메일
신탁
매우 큰 다중 사용자 기반 데이터베이스 관리 시스템입니다. Oracle은 'Oracle Corporation'에서 개발 한 관계형 데이터베이스 관리 시스템입니다.
오라클은 네트워크에서 데이터를 요청하고 전송하는 여러 클라이언트 간의 정보 데이터베이스 인 리소스를 효율적으로 관리하기 위해 노력하고 있습니다.
클라이언트 / 서버 컴퓨팅을위한 탁월한 데이터베이스 서버 선택입니다. Oracle은 MSDOS, NetWare, UnixWare, OS / 2 및 대부분의 UNIX 버전을 포함하여 클라이언트와 서버 모두에 대한 모든 주요 운영 체제를 지원합니다.
역사
Oracle은 1977 년에 시작하여 업계에서 32 년을 기념했습니다 (1977 년부터 2009 년까지).
1977-Larry Ellison, Bob Miner 및 Ed Oates는 개발 작업을 수행하기 위해 Software Development Laboratories를 설립했습니다.
1979-Oracle 버전 2.0이 출시되었으며 최초의 상용 관계형 데이터베이스 및 최초의 SQL 데이터베이스가되었습니다. 회사 이름은 RSI (Relational Software Inc.)로 변경되었습니다.
1981-RSI는 Oracle 용 도구 개발을 시작했습니다.
1982-RSI가 Oracle Corporation으로 이름이 변경되었습니다.
1983-Oracle은 버전 3.0을 출시했으며 C 언어로 다시 작성되었으며 여러 플랫폼에서 실행되었습니다.
1984-Oracle 버전 4.0이 출시되었습니다. 동시성 제어-다중 버전 읽기 일관성 등과 같은 기능이 포함되었습니다.
1985-Oracle 버전 4.0이 출시되었습니다. 동시성 제어-다중 버전 읽기 일관성 등과 같은 기능이 포함되었습니다.
2007-Oracle은 Oracle11g를 출시했습니다. 새 버전은 더 나은 파티셔닝, 쉬운 마이그레이션 등에 중점을 둡니다.
풍모
- Concurrency
- 일관성 읽기
- 잠금 메커니즘
- 데이터베이스 정지
- Portability
- 자가 관리 데이터베이스
- SQL*Plus
- ASM
- Scheduler
- 리소스 관리자
- 데이터웨어 하우징
- 구체화 된 뷰
- 비트 맵 인덱스
- 테이블 압축
- 병렬 실행
- 분석 SQL
- 데이터 수집
- Partitioning
MS 액세스
이것은 가장 인기있는 Microsoft 제품 중 하나입니다. Microsoft Access는 보급형 데이터베이스 관리 소프트웨어입니다. MS Access 데이터베이스는 저렴할뿐만 아니라 소규모 프로젝트를위한 강력한 데이터베이스입니다.
MS Access는 특정 SQL 언어 (Jet SQL이라고도 함)를 사용하는 Jet 데이터베이스 엔진을 사용합니다.
MS Access는 MS Office 패키지의 프로페셔널 에디션과 함께 제공됩니다. MS Access에는 사용하기 쉬운 직관적 인 그래픽 인터페이스가 있습니다.
1992-Access 버전 1.0이 출시되었습니다.
1993-Access Basic 프로그래밍 언어 포함과의 호환성을 개선하기 위해 Access 1.1이 출시되었습니다.
가장 중요한 전환은 Access 97에서 Access 2000으로의 전환이었습니다.
2007-Access 2007, 다중 값 및 첨부 필드와 같은 복잡한 데이터 유형을 지원하는 새로운 데이터베이스 형식 ACCDB가 도입되었습니다.
풍모
사용자는 테이블, 쿼리, 양식 및 보고서를 만들고 매크로와 함께 연결할 수 있습니다.
Excel, Outlook, ASCII, dBase, Paradox, FoxPro, SQL Server, Oracle, ODBC 등 다양한 형식으로 데이터 가져 오기 및 내보내기 옵션
또한 하나의 파일에 응용 프로그램과 데이터를 포함 할 수있는 Jet 데이터베이스 형식 (Access 2007의 MDB 또는 ACCDB)도 있습니다. 따라서 전체 애플리케이션을 연결이 끊긴 환경에서 실행할 수있는 다른 사용자에게 배포하는 것이 매우 편리합니다.
Microsoft Access는 매개 변수가있는 쿼리를 제공합니다. 이러한 쿼리 및 액세스 테이블은 DAO 또는 ADO를 통해 VB6 및 .NET과 같은 다른 프로그램에서 참조 할 수 있습니다.
Microsoft SQL Server의 데스크톱 버전은 Jet 데이터베이스 엔진의 대안으로 Access와 함께 사용할 수 있습니다.
Microsoft Access는 파일 서버 기반 데이터베이스입니다. 클라이언트-서버 관계형 데이터베이스 관리 시스템 (RDBMS)과 달리 Microsoft Access는 데이터베이스 트리거, 저장 프로 시저 또는 트랜잭션 로깅을 구현하지 않습니다.
SQL-구문
SQL 다음에는 구문이라는 고유 한 규칙 및 지침이 따릅니다. 이 자습서에서는 모든 기본 SQL 구문을 나열하여 SQL을 빠르게 시작할 수 있습니다.
모든 SQL 문은 SELECT, INSERT, UPDATE, DELETE, ALTER, DROP, CREATE, USE, SHOW와 같은 키워드로 시작하고 모든 문은 세미콜론 (;)으로 끝납니다.
여기서 주목해야 할 가장 중요한 점은 SQL이 대소 문자를 구분하지 않는다는 것입니다. 즉, SELECT와 select는 SQL 문에서 동일한 의미를 갖습니다. 반면 MySQL은 테이블 이름에 차이가 있습니다. 따라서 MySQL을 사용하는 경우 데이터베이스에있는 테이블 이름을 제공해야합니다.
SQL의 다양한 구문
이 자습서에 제공된 모든 예제는 MySQL 서버에서 테스트되었습니다.
SQL SELECT 문
SELECT column1, column2....columnN
FROM table_name;SQL DISTINCT 절
SELECT DISTINCT column1, column2....columnN
FROM table_name;SQL WHERE 절
SELECT column1, column2....columnN
FROM table_name
WHERE CONDITION;SQL AND / OR 절
SELECT column1, column2....columnN
FROM table_name
WHERE CONDITION-1 {AND|OR} CONDITION-2;SQL IN 절
SELECT column1, column2....columnN
FROM table_name
WHERE column_name IN (val-1, val-2,...val-N);SQL BETWEEN 절
SELECT column1, column2....columnN
FROM table_name
WHERE column_name BETWEEN val-1 AND val-2;SQL LIKE 절
SELECT column1, column2....columnN
FROM table_name
WHERE column_name LIKE { PATTERN };SQL ORDER BY 절
SELECT column1, column2....columnN
FROM table_name
WHERE CONDITION
ORDER BY column_name {ASC|DESC};SQL GROUP BY 절
SELECT SUM(column_name)
FROM table_name
WHERE CONDITION
GROUP BY column_name;SQL COUNT 절
SELECT COUNT(column_name)
FROM table_name
WHERE CONDITION;SQL HAVING 절
SELECT SUM(column_name)
FROM table_name
WHERE CONDITION
GROUP BY column_name
HAVING (arithematic function condition);SQL CREATE TABLE 문
CREATE TABLE table_name(
column1 datatype,
column2 datatype,
column3 datatype,
.....
columnN datatype,
PRIMARY KEY( one or more columns )
);SQL DROP TABLE 문
DROP TABLE table_name;SQL CREATE INDEX 문
CREATE UNIQUE INDEX index_name
ON table_name ( column1, column2,...columnN);SQL DROP INDEX 문
ALTER TABLE table_name
DROP INDEX index_name;SQL DESC 문
DESC table_name;SQL TRUNCATE TABLE 문
TRUNCATE TABLE table_name;SQL ALTER TABLE 문
ALTER TABLE table_name {ADD|DROP|MODIFY} column_name {data_ype};SQL ALTER TABLE 문 (이름 바꾸기)
ALTER TABLE table_name RENAME TO new_table_name;SQL INSERT INTO 문
INSERT INTO table_name( column1, column2....columnN)
VALUES ( value1, value2....valueN);SQL UPDATE 문
UPDATE table_name
SET column1 = value1, column2 = value2....columnN=valueN
[ WHERE CONDITION ];SQL DELETE 문
DELETE FROM table_name
WHERE {CONDITION};SQL CREATE DATABASE 문
CREATE DATABASE database_name;SQL DROP DATABASE 문
DROP DATABASE database_name;SQL USE 문
USE database_name;SQL COMMIT 문
COMMIT;SQL ROLLBACK 문
ROLLBACK;SQL-데이터 유형
SQL 데이터 유형은 모든 개체의 데이터 유형을 지정하는 속성입니다. 각 열, 변수 및 표현식에는 SQL의 관련 데이터 유형이 있습니다. 테이블을 생성하는 동안 이러한 데이터 유형을 사용할 수 있습니다. 요구 사항에 따라 테이블 열의 데이터 유형을 선택할 수 있습니다.
SQL Server는 아래에 나열된 여섯 가지 범주의 데이터 유형을 제공합니다.
정확한 숫자 데이터 유형
| 데이터 형식 | 에서 | 에 |
|---|---|---|
| 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 |
| 작은 | 0 | 255 |
| 비트 | 0 | 1 |
| 소수 | -10 ^ 38 +1 | 10 ^ 38 -1 |
| 숫자 | -10 ^ 38 +1 | 10 ^ 38 -1 |
| 돈 | -922,337,203,685,477.5808 | +922,337,203,685,477.5807 |
| 작은 돈 | -214,748.3648 | +214,748.3647 |
대략적인 숫자 데이터 유형
| 데이터 형식 | 에서 | 에 |
|---|---|---|
| 흙손 | -1.79E + 308 | 1.79E + 308 |
| 레알 | -3.40E + 38 | 3.40E + 38 |
날짜 및 시간 데이터 유형
| 데이터 형식 | 에서 | 에 |
|---|---|---|
| 날짜 시간 | 1753 년 1 월 1 일 | 9999 년 12 월 31 일 |
| smalldatetime | 1900 년 1 월 1 일 | 2079 년 6 월 6 일 |
| 데이트 | 1991 년 6 월 30 일과 같은 날짜를 저장합니다. | |
| 시각 | 오후 12시 30 분과 같은 시간을 저장합니다. | |
Note − 여기서 datetime은 3.33 밀리 초의 정확도를 가지며 smalldatetime은 1 분의 정확도를가집니다.
문자열 데이터 유형
| Sr. 아니. | 데이터 유형 및 설명 |
|---|---|
| 1 | char 최대 길이는 8,000 자 (유니 코드가 아닌 고정 길이) |
| 2 | varchar 최대 8,000 자 (유니 코드가 아닌 가변 길이 데이터). |
| 삼 | varchar(max) 최대 길이 2E + 31 자, 가변 길이 비 유니 코드 데이터 (SQL Server 2005에만 해당). |
| 4 | text 최대 길이가 2,147,483,647자인 가변 길이 비 유니 코드 데이터. |
유니 코드 문자열 데이터 유형
| Sr. 아니. | 데이터 유형 및 설명 |
|---|---|
| 1 | nchar 최대 4,000 자 (고정 길이 유니 코드) |
| 2 | nvarchar 최대 4,000 자 (가변 길이 유니 코드) |
| 삼 | nvarchar(max) 최대 길이 2E + 31 자 (SQL Server 2005에만 해당) (가변 길이 유니 코드) |
| 4 | ntext 최대 길이는 1,073,741,823 자입니다. (가변 길이 유니 코드) |
이진 데이터 유형
| Sr. 아니. | 데이터 유형 및 설명 |
|---|---|
| 1 | binary 최대 길이 8,000 바이트 (고정 길이 바이너리 데이터) |
| 2 | varbinary 최대 길이 8,000 바이트 (가변 길이 바이너리 데이터) |
| 삼 | varbinary(max) 최대 길이는 2E + 31 바이트입니다 (SQL Server 2005에만 해당). (가변 길이 이진 데이터) |
| 4 | image 최대 길이는 2,147,483,647 바이트입니다. (가변 길이 이진 데이터) |
기타 데이터 유형
| Sr. 아니. | 데이터 유형 및 설명 |
|---|---|
| 1 | sql_variant text, ntext 및 timestamp를 제외한 다양한 SQL Server 지원 데이터 형식의 값을 저장합니다. |
| 2 | timestamp 행이 업데이트 될 때마다 업데이트되는 데이터베이스 전체 고유 번호를 저장합니다. |
| 삼 | uniqueidentifier GUID (Globally Unique Identifier)를 저장합니다. |
| 4 | xml XML 데이터를 저장합니다. 열 또는 변수에 xml 인스턴스를 저장할 수 있습니다 (SQL Server 2005에만 해당). |
| 5 | cursor 커서 개체에 대한 참조 |
| 6 | table 나중에 처리 할 수 있도록 결과 집합을 저장합니다. |
SQL-연산자
SQL에서 연산자는 무엇입니까?
연산자는 예약어 또는 주로 SQL 문의 WHERE 절에서 비교 및 산술 연산과 같은 연산을 수행하는 데 사용되는 문자입니다. 이러한 연산자는 SQL 문에서 조건을 지정하고 명령문에서 여러 조건에 대한 접속사 역할을하는 데 사용됩니다.
- 산술 연산자
- 비교 연산자
- 논리 연산자
- 조건을 부정하는 데 사용되는 연산자
SQL 산술 연산자
취하다 'variable a' 10 개를 보유하고 'variable b' 20 개를 보유하면-
예시보기
| 운영자 | 기술 | 예 |
|---|---|---|
| + (추가) | 연산자의 양쪽에 값을 추가합니다. | a + b는 30을 줄 것입니다 |
| -(빼기) | 왼손 피연산자에서 오른손 피연산자를 뺍니다. | a-b는 -10을 줄 것입니다. |
| * (곱하기) | 연산자의 양쪽에있는 값을 곱합니다. | a * b는 200을 줄 것입니다 |
| / (나누기) | 왼손 피연산자를 오른손 피연산자로 나눕니다. | b / a는 2를 줄 것입니다 |
| % (모듈러스) | 왼손 피연산자를 오른손 피연산자로 나누고 나머지를 반환합니다. | b % a는 0을 제공합니다. |
SQL 비교 연산자
취하다 'variable a' 10 개를 보유하고 'variable b' 20 개를 보유하면-
예시보기
| 운영자 | 기술 | 예 |
|---|---|---|
| = | 두 피연산자의 값이 같은지 확인하고, 예이면 조건이 참이됩니다. | (a = b)는 사실이 아닙니다. |
| ! = | 두 피연산자의 값이 같은지 확인하고, 값이 같지 않으면 조건이 참이됩니다. | (a! = b)는 참입니다. |
| <> | 두 피연산자의 값이 같은지 확인하고, 값이 같지 않으면 조건이 참이됩니다. | (a <> b)가 참입니다. |
| > | 왼쪽 피연산자의 값이 오른쪽 피연산자의 값보다 큰지 확인하고, 그렇다면 조건이 참이됩니다. | (a> b)는 사실이 아닙니다. |
| < | 왼쪽 피연산자의 값이 오른쪽 피연산자의 값보다 작은 지 확인하고, 그렇다면 조건이 참이됩니다. | (a <b)는 참입니다. |
| > = | 왼쪽 피연산자의 값이 오른쪽 피연산자의 값보다 크거나 같은지 확인하고, 그렇다면 조건이 참이됩니다. | (a> = b)는 사실이 아닙니다. |
| <= | 왼쪽 피연산자의 값이 오른쪽 피연산자의 값보다 작거나 같은지 확인하고, 그렇다면 조건이 참이됩니다. | (a <= b)는 참입니다. |
| ! < | 왼쪽 피연산자의 값이 오른쪽 피연산자의 값보다 작지 않은지 확인하고, 그렇다면 조건이 참이됩니다. | (a! <b)는 거짓입니다. |
| !> | 왼쪽 피연산자의 값이 오른쪽 피연산자의 값보다 크지 않은지 확인하고, 그렇다면 조건이 참이됩니다. | (a!> b)는 참입니다. |
SQL 논리 연산자
다음은 SQL에서 사용할 수있는 모든 논리 연산자의 목록입니다.
예시보기
| Sr. 아니. | 연산자 및 설명 |
|---|---|
| 1 | ALL ALL 연산자는 값을 다른 값 집합의 모든 값과 비교하는 데 사용됩니다. |
| 2 | AND AND 연산자를 사용하면 SQL 문의 WHERE 절에 여러 조건이있을 수 있습니다. |
| 삼 | ANY ANY 연산자는 조건에 따라 값을 목록의 적용 가능한 값과 비교하는 데 사용됩니다. |
| 4 | BETWEEN BETWEEN 연산자는 최소값과 최대 값이 주어진 경우 값 집합 내에있는 값을 검색하는 데 사용됩니다. |
| 5 | EXISTS EXISTS 연산자는 특정 기준을 충족하는 지정된 테이블에서 행이 있는지 검색하는 데 사용됩니다. |
| 6 | IN IN 연산자는 값을 지정된 리터럴 값 목록과 비교하는 데 사용됩니다. |
| 7 | LIKE LIKE 연산자는 와일드 카드 연산자를 사용하여 값을 유사한 값과 비교하는 데 사용됩니다. |
| 8 | NOT NOT 연산자는 사용되는 논리 연산자의 의미를 반대로합니다. 예 : 존재하지 않음, 사이에 없음, 안으로 없음 등This is a negate operator. |
| 9 | OR OR 연산자는 SQL 문의 WHERE 절에서 여러 조건을 결합하는 데 사용됩니다. |
| 10 | IS NULL NULL 연산자는 값을 NULL 값과 비교하는 데 사용됩니다. |
| 11 | UNIQUE UNIQUE 연산자는 지정된 테이블의 모든 행에서 고유성을 검색합니다 (중복 없음). |
SQL-표현식
표현식은 값으로 평가되는 하나 이상의 값, 연산자 및 SQL 함수의 조합입니다. 이러한 SQL EXPRESSION은 수식과 유사하며 쿼리 언어로 작성됩니다. 또한 특정 데이터 세트에 대해 데이터베이스를 쿼리하는 데 사용할 수도 있습니다.
통사론
다음과 같이 SELECT 문의 기본 구문을 고려하십시오-
SELECT column1, column2, columnN
FROM table_name
WHERE [CONDITION|EXPRESSION];아래에 언급 된 다양한 유형의 SQL 표현식이 있습니다.
- Boolean
- Numeric
- Date
이제 각각에 대해 자세히 설명하겠습니다.
부울 식
SQL 부울 표현식은 단일 값 일치를 기반으로 데이터를 가져옵니다. 다음은 구문입니다-
SELECT column1, column2, columnN
FROM table_name
WHERE SINGLE VALUE MATCHING EXPRESSION;다음 레코드가있는 CUSTOMERS 테이블을 고려하십시오.
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)다음 표는 다양한 SQL 부울 표현식의 사용법을 보여주는 간단한 예입니다.
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)숫자 식
이러한 식은 모든 쿼리에서 수학적 연산을 수행하는 데 사용됩니다. 다음은 구문입니다-
SELECT numerical_expression as OPERATION_NAME
[FROM table_name
WHERE CONDITION] ;여기서 numeric_expression은 수학적 표현식 또는 공식에 사용됩니다. 다음은 SQL Numeric Expressions의 사용법을 보여주는 간단한 예입니다.
SQL> SELECT (15 + 6) AS ADDITION
+----------+
| ADDITION |
+----------+
| 21 |
+----------+
1 row in set (0.00 sec)avg (), sum (), count () 등과 같은 몇 가지 내장 함수가있어 테이블 또는 특정 테이블 열에 대해 집계 데이터 계산이라고하는 것을 수행합니다.
SQL> SELECT COUNT(*) AS "RECORDS" FROM CUSTOMERS;
+---------+
| RECORDS |
+---------+
| 7 |
+---------+
1 row in set (0.00 sec)날짜 표현
날짜 표현식은 현재 시스템 날짜 및 시간 값을 반환합니다-
SQL> SELECT CURRENT_TIMESTAMP;
+---------------------+
| Current_Timestamp |
+---------------------+
| 2009-11-12 06:40:23 |
+---------------------+
1 row in set (0.00 sec)다른 날짜 표현은 아래와 같습니다.
SQL> SELECT GETDATE();;
+-------------------------+
| GETDATE |
+-------------------------+
| 2009-10-22 12:07:18.140 |
+-------------------------+
1 row in set (0.00 sec)SQL-데이터베이스 생성
SQL CREATE DATABASE 문은 새 SQL 데이터베이스를 만드는 데 사용됩니다.
통사론
이 CREATE DATABASE 문의 기본 구문은 다음과 같습니다.
CREATE DATABASE DatabaseName;항상 데이터베이스 이름은 RDBMS 내에서 고유해야합니다.
예
새 데이터베이스 <testDB>를 생성하려면 CREATE DATABASE 문은 다음과 같습니다.
SQL> CREATE DATABASE testDB;데이터베이스를 생성하기 전에 관리자 권한이 있는지 확인하십시오. 데이터베이스가 생성되면 다음과 같이 데이터베이스 목록에서 확인할 수 있습니다.
SQL> SHOW DATABASES;
+--------------------+
| Database |
+--------------------+
| information_schema |
| AMROOD |
| TUTORIALSPOINT |
| mysql |
| orig |
| test |
| testDB |
+--------------------+
7 rows in set (0.00 sec)SQL-DROP 또는 DELETE 데이터베이스
SQL DROP DATABASE 문은 SQL 스키마에서 기존 데이터베이스를 삭제하는 데 사용됩니다.
통사론
DROP DATABASE 문의 기본 구문은 다음과 같습니다.
DROP DATABASE DatabaseName;항상 데이터베이스 이름은 RDBMS 내에서 고유해야합니다.
예
기존 데이터베이스 <testDB>를 삭제하려는 경우 DROP DATABASE 문은 다음과 같습니다.
SQL> DROP DATABASE testDB;NOTE − 기존 데이터베이스를 삭제하면 데이터베이스에 저장된 전체 정보가 손실 될 수 있으므로이 작업을 사용하기 전에주의하십시오.
데이터베이스를 삭제하기 전에 관리자 권한이 있는지 확인하십시오. 데이터베이스가 삭제되면 아래와 같이 데이터베이스 목록에서 확인할 수 있습니다.
SQL> SHOW DATABASES;
+--------------------+
| Database |
+--------------------+
| information_schema |
| AMROOD |
| TUTORIALSPOINT |
| mysql |
| orig |
| test |
+--------------------+
6 rows in set (0.00 sec)SQL-SELECT 데이터베이스, USE 문
SQL 스키마에 여러 데이터베이스가있는 경우 작업을 시작하기 전에 모든 작업이 수행 될 데이터베이스를 선택해야합니다.
SQL USE 문은 SQL 스키마에서 기존 데이터베이스를 선택하는 데 사용됩니다.
통사론
USE 문의 기본 구문은 다음과 같습니다.
USE DatabaseName;항상 데이터베이스 이름은 RDBMS 내에서 고유해야합니다.
예
아래와 같이 사용 가능한 데이터베이스를 확인할 수 있습니다.
SQL> SHOW DATABASES;
+--------------------+
| Database |
+--------------------+
| information_schema |
| AMROOD |
| TUTORIALSPOINT |
| mysql |
| orig |
| test |
+--------------------+
6 rows in set (0.00 sec)이제 AMROOD 데이터베이스로 작업하려면 다음 SQL 명령을 실행하고 AMROOD 데이터베이스 작업을 시작할 수 있습니다.
SQL> USE AMROOD;SQL-테이블 생성
기본 테이블을 만들려면 테이블 이름을 지정하고 해당 열과 각 열의 데이터 유형을 정의해야합니다.
SQL CREATE TABLE 문은 새 테이블을 만드는 데 사용됩니다.
통사론
CREATE TABLE 문의 기본 구문은 다음과 같습니다.
CREATE TABLE table_name(
column1 datatype,
column2 datatype,
column3 datatype,
.....
columnN datatype,
PRIMARY KEY( one or more columns )
);CREATE TABLE은 수행 할 작업을 데이터베이스 시스템에 알려주는 키워드입니다. 이 경우 새 테이블을 생성하려고합니다. 테이블의 고유 이름 또는 식별자는 CREATE TABLE 문 뒤에옵니다.
그런 다음 괄호 안에 테이블의 각 열과 데이터 유형이 무엇인지 정의하는 목록이 있습니다. 다음 예제를 사용하면 구문이 더 명확 해집니다.
CREATE TABLE 문과 SELECT 문을 조합하여 기존 테이블의 복사본을 만들 수 있습니다. 전체 세부 정보는 다른 테이블을 사용하여 테이블 만들기 에서 확인할 수 있습니다 .
예
다음 코드 블록은 ID를 기본 키로 사용하여 CUSTOMERS 테이블을 생성하는 예이며 NOT NULL은이 테이블에서 레코드를 생성하는 동안 이러한 필드가 NULL이 될 수 없음을 보여주는 제약입니다.
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)
);SQL 서버가 표시하는 메시지를보고 테이블이 성공적으로 생성되었는지 확인할 수 있습니다. 그렇지 않으면 다음을 사용할 수 있습니다. DESC 다음과 같이 명령-
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)이제 고객과 관련된 필수 정보를 저장하는 데 사용할 수있는 데이터베이스에서 CUSTOMERS 테이블을 사용할 수 있습니다.
SQL-DROP 또는 DELETE 테이블
SQL DROP TABLE 문은 테이블 정의와 해당 테이블에 대한 모든 데이터, 인덱스, 트리거, 제약 조건 및 권한 사양을 제거하는 데 사용됩니다.
NOTE − 일단 테이블이 삭제되면 해당 테이블에서 사용 가능한 모든 정보도 영원히 손실되므로이 명령을 사용하는 동안 매우주의해야합니다.
통사론
이 DROP TABLE 문의 기본 구문은 다음과 같습니다.
DROP TABLE table_name;예
먼저 CUSTOMERS 테이블을 확인한 다음 아래와 같이 데이터베이스에서 삭제하겠습니다.
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)이는 데이터베이스에서 CUSTOMERS 테이블을 사용할 수 있음을 의미하므로 이제 아래와 같이 삭제하겠습니다.
SQL> DROP TABLE CUSTOMERS;
Query OK, 0 rows affected (0.01 sec)이제 DESC 명령을 시도하면 다음과 같은 오류가 발생합니다.
SQL> DESC CUSTOMERS;
ERROR 1146 (42S02): Table 'TEST.CUSTOMERS' doesn't exist여기서 TEST는 예제에 사용하는 데이터베이스 이름입니다.
SQL-INSERT 쿼리
SQL INSERT INTO 문은 데이터베이스의 테이블에 새 데이터 행을 추가하는 데 사용됩니다.
통사론
아래에 표시된 INSERT INTO 문의 두 가지 기본 구문이 있습니다.
INSERT INTO TABLE_NAME (column1, column2, column3,...columnN)
VALUES (value1, value2, value3,...valueN);여기서 column1, column2, column3, ... columnN은 데이터를 삽입하려는 테이블의 열 이름입니다.
테이블의 모든 열에 대한 값을 추가하는 경우 SQL 쿼리에서 열 이름을 지정할 필요가 없습니다. 그러나 값의 순서가 테이블의 열과 동일한 순서인지 확인하십시오.
그만큼 SQL INSERT INTO 구문은 다음과 같습니다-
INSERT INTO TABLE_NAME VALUES (value1,value2,value3,...valueN);예
다음 문은 CUSTOMERS 테이블에 6 개의 레코드를 만듭니다.
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 );아래와 같이 두 번째 구문을 사용하여 CUSTOMERS 테이블에 레코드를 만들 수 있습니다.
INSERT INTO CUSTOMERS
VALUES (7, 'Muffy', 24, 'Indore', 10000.00 );위의 모든 문은 아래와 같이 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 |
+----+----------+-----+-----------+----------+다른 테이블을 사용하여 한 테이블 채우기
다른 테이블에 대한 select 문을 통해 테이블에 데이터를 채울 수 있습니다. 다른 테이블에 첫 번째 테이블을 채우는 데 필요한 필드 세트가있는 경우.
다음은 구문입니다.
INSERT INTO first_table_name [(column1, column2, ... columnN)]
SELECT column1, column2, ...columnN
FROM second_table_name
[WHERE condition];SQL-SELECT 쿼리
SQL SELECT문은이 데이터를 결과 테이블 형식으로 반환하는 데이터베이스 테이블에서 데이터를 가져 오는 데 사용됩니다. 이러한 결과 테이블을 결과 세트라고합니다.
통사론
SELECT 문의 기본 구문은 다음과 같습니다.
SELECT column1, column2, columnN FROM table_name;여기서 column1, column2 ...는 값을 가져 오려는 테이블의 필드입니다. 필드에서 사용 가능한 모든 필드를 가져 오려면 다음 구문을 사용할 수 있습니다.
SELECT * FROM table_name;예
다음 레코드가있는 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 |
+----+----------+-----+-----------+----------+다음 코드는 CUSTOMERS 테이블에서 사용 가능한 고객의 ID, Name 및 Salary 필드를 가져 오는 예제입니다.
SQL> SELECT ID, NAME, SALARY FROM CUSTOMERS;이것은 다음 결과를 생성합니다-
+----+----------+----------+
| 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 |
+----+----------+----------+CUSTOMERS 테이블의 모든 필드를 가져 오려면 다음 쿼리를 사용해야합니다.
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 |
+----+----------+-----+-----------+----------+SQL-WHERE 절
SQL WHERE절은 단일 테이블에서 데이터를 가져 오거나 여러 테이블과 결합하여 조건을 지정하는 데 사용됩니다. 주어진 조건이 충족되면 테이블에서 특정 값만 반환합니다. WHERE 절을 사용하여 레코드를 필터링하고 필요한 레코드 만 가져와야합니다.
WHERE 절은 SELECT 문에서만 사용되는 것이 아니라 다음 장에서 살펴볼 UPDATE, DELETE 문 등에서도 사용됩니다.
통사론
WHERE 절이있는 SELECT 문의 기본 구문은 다음과 같습니다.
SELECT column1, column2, columnN
FROM table_name
WHERE [condition]비교 또는 >, <, =, 등의 논리 연산자를 사용하여 조건을 지정할 수 있습니다 .LIKE, NOT, 등. 다음 예는이 개념을 명확하게합니다.
예
다음 레코드가있는 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 |
+----+----------+-----+-----------+----------+다음 코드는 급여가 2000보다 큰 CUSTOMERS 테이블에서 ID, 이름 및 급여 필드를 가져 오는 예제입니다.
SQL> SELECT ID, NAME, SALARY
FROM CUSTOMERS
WHERE SALARY > 2000;이것은 다음 결과를 생성합니다-
+----+----------+----------+
| ID | NAME | SALARY |
+----+----------+----------+
| 4 | Chaitali | 6500.00 |
| 5 | Hardik | 8500.00 |
| 6 | Komal | 4500.00 |
| 7 | Muffy | 10000.00 |
+----+----------+----------+다음 쿼리는 이름이있는 고객의 CUSTOMERS 테이블에서 ID, Name 및 Salary 필드를 가져 오는 예제입니다. Hardik.
여기서 모든 문자열은 작은 따옴표 ( '') 안에 넣어야한다는 점에 유의해야합니다. 반면, 숫자 값은 위의 예에서와 같이 따옴표없이 제공되어야합니다.SQL> SELECT ID, NAME, SALARY
FROM CUSTOMERS
WHERE NAME = 'Hardik';이것은 다음 결과를 생성합니다-
+----+----------+----------+
| ID | NAME | SALARY |
+----+----------+----------+
| 5 | Hardik | 8500.00 |
+----+----------+----------+SQL-AND 및 OR 결합 연산자
SQL AND & OR연산자는 SQL 문에서 데이터 범위를 좁히기 위해 여러 조건을 결합하는 데 사용됩니다. 이 두 연산자를 결합 연산자라고합니다.
이러한 연산자는 동일한 SQL 문에서 다른 연산자와 여러 비교를 수행하는 방법을 제공합니다.
AND 연산자
그만큼 AND 연산자는 SQL 문의 WHERE 절에 여러 조건의 존재를 허용합니다.
통사론
WHERE 절이있는 AND 연산자의 기본 구문은 다음과 같습니다.
SELECT column1, column2, columnN
FROM table_name
WHERE [condition1] AND [condition2]...AND [conditionN];AND 연산자를 사용하여 N 개의 조건을 결합 할 수 있습니다. 트랜잭션이든 쿼리이든 SQL 문에서 수행 할 작업의 경우 AND로 구분 된 모든 조건은 TRUE 여야합니다.
예
다음 레코드가있는 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 |
+----+----------+-----+-----------+----------+다음은 급여가 2000보다 크고 나이가 25 세 미만인 CUSTOMERS 테이블에서 ID, Name 및 Salary 필드를 가져 오는 예입니다.
SQL> SELECT ID, NAME, SALARY
FROM CUSTOMERS
WHERE SALARY > 2000 AND age < 25;이것은 다음 결과를 생성합니다-
+----+-------+----------+
| ID | NAME | SALARY |
+----+-------+----------+
| 6 | Komal | 4500.00 |
| 7 | Muffy | 10000.00 |
+----+-------+----------+OR 연산자
OR 연산자는 SQL 문의 WHERE 절에서 여러 조건을 결합하는 데 사용됩니다.
통사론
WHERE 절이있는 OR 연산자의 기본 구문은 다음과 같습니다.
SELECT column1, column2, columnN
FROM table_name
WHERE [condition1] OR [condition2]...OR [conditionN]OR 연산자를 사용하여 N 개의 조건을 결합 할 수 있습니다. 트랜잭션이든 쿼리이든 SQL 문에서 수행 할 작업의 경우 OR로 구분 된 조건 중 하나만 TRUE 여야합니다.
예
다음 레코드가있는 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 |
+----+----------+-----+-----------+----------+다음 코드 블록에는 CUSTOMERS 테이블에서 ID, Name 및 Salary 필드를 가져 오는 쿼리가 있습니다. 여기서 급여가 2000보다 크거나 나이가 25 세 미만입니다.
SQL> SELECT ID, NAME, SALARY
FROM CUSTOMERS
WHERE SALARY > 2000 OR age < 25;이것은 다음 결과를 생성합니다-
+----+----------+----------+
| 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 쿼리
SQL UPDATE쿼리는 테이블의 기존 레코드를 수정하는 데 사용됩니다. UPDATE 쿼리와 함께 WHERE 절을 사용하여 선택한 행을 업데이트 할 수 있습니다. 그렇지 않으면 모든 행이 영향을받습니다.
통사론
WHERE 절이있는 UPDATE 쿼리의 기본 구문은 다음과 같습니다.
UPDATE table_name
SET column1 = value1, column2 = value2...., columnN = valueN
WHERE [condition];AND 또는 OR 연산자를 사용하여 N 개의 조건을 결합 할 수 있습니다.
예
다음 레코드가있는 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 |
+----+----------+-----+-----------+----------+다음 쿼리는 테이블에서 ID 번호가 6 인 고객의 ADDRESS를 업데이트합니다.
SQL> UPDATE CUSTOMERS
SET ADDRESS = 'Pune'
WHERE ID = 6;이제 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 | Pune | 4500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+----------+-----+-----------+----------+CUSTOMERS 테이블의 모든 ADDRESS 및 SALARY 열 값을 수정하려는 경우 다음 코드 블록과 같이 UPDATE 쿼리로 충분하므로 WHERE 절을 사용할 필요가 없습니다.
SQL> UPDATE CUSTOMERS
SET ADDRESS = 'Pune', SALARY = 1000.00;이제 CUSTOMERS 테이블에는 다음과 같은 레코드가 있습니다.
+----+----------+-----+---------+---------+
| 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-쿼리 삭제
SQL DELETE 쿼리는 테이블에서 기존 레코드를 삭제하는 데 사용됩니다.
DELETE 쿼리와 함께 WHERE 절을 사용하여 선택한 행을 삭제할 수 있습니다. 그렇지 않으면 모든 레코드가 삭제됩니다.
통사론
WHERE 절이있는 DELETE 쿼리의 기본 구문은 다음과 같습니다.
DELETE FROM table_name
WHERE [condition];AND 또는 OR 연산자를 사용하여 N 개의 조건을 결합 할 수 있습니다.
예
다음 레코드가있는 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 |
+----+----------+-----+-----------+----------+다음 코드에는 ID가 6 인 고객을 삭제하는 쿼리가 있습니다.
SQL> DELETE FROM CUSTOMERS
WHERE ID = 6;이제 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 |
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+----------+-----+-----------+----------+CUSTOMERS 테이블에서 모든 레코드를 삭제하려면 WHERE 절을 사용할 필요가 없으며 DELETE 쿼리는 다음과 같습니다.
SQL> DELETE FROM CUSTOMERS;이제 CUSTOMERS 테이블에는 레코드가 없습니다.
SQL-LIKE 절
SQL LIKE절은 와일드 카드 연산자를 사용하여 값을 유사한 값과 비교하는 데 사용됩니다. LIKE 연산자와 함께 사용되는 두 개의 와일드 카드가 있습니다.
- 백분율 기호 (%)
- 밑줄 (_)
퍼센트 기호는 0 개, 1 개 또는 여러 문자를 나타냅니다. 밑줄은 단일 숫자 또는 문자를 나타냅니다. 이러한 기호는 조합하여 사용할 수 있습니다.
통사론
% 및 _의 기본 구문은 다음과 같습니다.
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_'AND 또는 OR 연산자를 사용하여 N 개의 조건을 결합 할 수 있습니다. 여기서 XXXX는 숫자 또는 문자열 값이 될 수 있습니다.
예
다음 표에는 '%'및 '_'연산자가있는 다른 LIKE 절을 갖는 WHERE 부분을 보여주는 몇 가지 예가 있습니다.
| Sr. 아니. | 성명 및 설명 |
|---|---|
| 1 | WHERE SALARY LIKE '200%' 200으로 시작하는 모든 값을 찾습니다. |
| 2 | WHERE SALARY LIKE '%200%' 임의의 위치에 200이있는 모든 값을 찾습니다. |
| 삼 | WHERE SALARY LIKE '_00%' 두 번째 및 세 번째 위치에 00이있는 모든 값을 찾습니다. |
| 4 | WHERE SALARY LIKE '2_%_%' 2로 시작하고 길이가 3 자 이상인 모든 값을 찾습니다. |
| 5 | WHERE SALARY LIKE '%2' 2로 끝나는 모든 값을 찾습니다. |
| 6 | WHERE SALARY LIKE '_2%3' 두 번째 위치에 2가 있고 3으로 끝나는 값을 찾습니다. |
| 7 | WHERE SALARY LIKE '2___3' 2로 시작하고 3으로 끝나는 5 자리 숫자의 값을 찾습니다. |
실제 예를 들어 아래에 표시된 레코드가있는 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 |
+----+----------+-----+-----------+----------+다음은 SALARY가 200으로 시작하는 CUSTOMERS 테이블의 모든 레코드를 표시하는 예입니다.
SQL> SELECT * FROM CUSTOMERS
WHERE SALARY LIKE '200%';이것은 다음 결과를 생성합니다-
+----+----------+-----+-----------+----------+
| ID | NAME | AGE | ADDRESS | SALARY |
+----+----------+-----+-----------+----------+
| 1 | Ramesh | 32 | Ahmedabad | 2000.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
+----+----------+-----+-----------+----------+SQL-TOP, LIMIT 또는 ROWNUM 절
SQL TOP 절은 테이블에서 TOP N 번호 또는 X % 레코드를 가져 오는 데 사용됩니다.
Note− 모든 데이터베이스가 TOP 절을 지원하지 않습니다. 예를 들어 MySQL은LIMIT Oracle이 사용하는 동안 제한된 수의 레코드를 가져 오는 절 ROWNUM 제한된 수의 레코드를 가져 오는 명령.
통사론
SELECT 문이있는 TOP 절의 기본 구문은 다음과 같습니다.
SELECT TOP number|percent column_name(s)
FROM table_name
WHERE [condition]예
다음 레코드가있는 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 |
+----+----------+-----+-----------+----------+다음 쿼리는 CUSTOMERS 테이블에서 상위 3 개 레코드를 가져 오는 SQL 서버의 예입니다.
SQL> SELECT TOP 3 * 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 |
+----+---------+-----+-----------+---------+MySQL 서버를 사용하는 경우 여기에 동등한 예가 있습니다.
SQL> SELECT * FROM CUSTOMERS
LIMIT 3;이것은 다음 결과를 생성합니다-
+----+---------+-----+-----------+---------+
| ID | NAME | AGE | ADDRESS | SALARY |
+----+---------+-----+-----------+---------+
| 1 | Ramesh | 32 | Ahmedabad | 2000.00 |
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
+----+---------+-----+-----------+---------+Oracle 서버를 사용하는 경우 다음 코드 블록에 동일한 예제가 있습니다.
SQL> SELECT * FROM CUSTOMERS
WHERE ROWNUM <= 3;이것은 다음 결과를 생성합니다-
+----+---------+-----+-----------+---------+
| 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 절
SQL ORDER BY절은 하나 이상의 열을 기준으로 오름차순 또는 내림차순으로 데이터를 정렬하는 데 사용됩니다. 일부 데이터베이스는 기본적으로 쿼리 결과를 오름차순으로 정렬합니다.
통사론
ORDER BY 절의 기본 구문은 다음과 같습니다.
SELECT column-list
FROM table_name
[WHERE condition]
[ORDER BY column1, column2, .. columnN] [ASC | DESC];ORDER BY 절에서 둘 이상의 열을 사용할 수 있습니다. 해당 열을 정렬하는 데 사용하는 열이 열 목록에 있어야합니다.
예
다음 레코드가있는 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 |
+----+----------+-----+-----------+----------+다음 코드 블록에는 NAME과 SALARY에 따라 오름차순으로 결과를 정렬하는 예제가 있습니다.
SQL> SELECT * FROM CUSTOMERS
ORDER BY NAME, SALARY;이것은 다음 결과를 생성합니다-
+----+----------+-----+-----------+----------+
| 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 |
+----+----------+-----+-----------+----------+다음 코드 블록에는 NAME을 기준으로 결과를 내림차순으로 정렬하는 예제가 있습니다.
SQL> SELECT * FROM CUSTOMERS
ORDER BY NAME DESC;이것은 다음 결과를 생성합니다-
+----+----------+-----+-----------+----------+
| 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-그룹화 기준
SQL GROUP BY절은 SELECT 문과 협력하여 동일한 데이터를 그룹으로 배열하는 데 사용됩니다. 이 GROUP BY 절은 SELECT 문에서 WHERE 절을 따르고 ORDER BY 절 앞에옵니다.
통사론
GROUP BY 절의 기본 구문은 다음 코드 블록에 나와 있습니다. GROUP BY 절은 WHERE 절의 조건을 따라야하며 ORDER BY 절이 사용되는 경우 앞에 와야합니다.
SELECT column1, column2
FROM table_name
WHERE [ conditions ]
GROUP BY column1, column2
ORDER BY column1, column2예
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 |
+----+----------+-----+-----------+----------+각 고객의 급여 총액을 알고 싶다면 GROUP BY 쿼리는 다음과 같습니다.
SQL> SELECT NAME, SUM(SALARY) FROM CUSTOMERS
GROUP BY NAME;이것은 다음 결과를 생성합니다-
+----------+-------------+
| NAME | SUM(SALARY) |
+----------+-------------+
| Chaitali | 6500.00 |
| Hardik | 8500.00 |
| kaushik | 2000.00 |
| Khilan | 1500.00 |
| Komal | 4500.00 |
| Muffy | 10000.00 |
| Ramesh | 2000.00 |
+----------+-------------+이제 CUSTOMERS 테이블에 중복 이름이있는 다음 레코드가있는 테이블을 살펴 보겠습니다.
+----+----------+-----+-----------+----------+
| 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 |
+----+----------+-----+-----------+----------+다시 말하지만, 각 고객의 총 급여 금액을 알고 싶다면 GROUP BY 쿼리는 다음과 같습니다.
SQL> SELECT NAME, SUM(SALARY) FROM CUSTOMERS
GROUP BY NAME;이것은 다음 결과를 생성합니다-
+---------+-------------+
| NAME | SUM(SALARY) |
+---------+-------------+
| Hardik | 8500.00 |
| kaushik | 8500.00 |
| Komal | 4500.00 |
| Muffy | 10000.00 |
| Ramesh | 3500.00 |
+---------+-------------+SQL-고유 키워드
SQL DISTINCT 키워드는 SELECT 문과 함께 사용되어 모든 중복 레코드를 제거하고 고유 한 레코드 만 가져옵니다.
테이블에 중복 레코드가 여러 개있는 상황이있을 수 있습니다. 이러한 레코드를 가져 오는 동안 중복 레코드를 가져 오는 대신 고유 한 레코드 만 가져 오는 것이 더 합리적입니다.
통사론
중복 레코드를 제거하는 DISTINCT 키워드의 기본 구문은 다음과 같습니다.
SELECT DISTINCT column1, column2,.....columnN
FROM table_name
WHERE [condition]예
다음 레코드가있는 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 |
+----+----------+-----+-----------+----------+먼저 다음 SELECT 쿼리가 중복 급여 레코드를 반환하는 방법을 살펴 보겠습니다.
SQL> SELECT SALARY FROM CUSTOMERS
ORDER BY SALARY;이것은 원래 테이블의 중복 레코드 인 급여 (2000)가 두 번 나오는 다음 결과를 생성합니다.
+----------+
| SALARY |
+----------+
| 1500.00 |
| 2000.00 |
| 2000.00 |
| 4500.00 |
| 6500.00 |
| 8500.00 |
| 10000.00 |
+----------+이제 위의 SELECT 쿼리에 DISTINCT 키워드를 사용한 다음 결과를 확인하겠습니다.
SQL> SELECT DISTINCT SALARY FROM CUSTOMERS
ORDER BY SALARY;중복 항목이없는 경우 다음과 같은 결과가 생성됩니다.
+----------+
| SALARY |
+----------+
| 1500.00 |
| 2000.00 |
| 4500.00 |
| 6500.00 |
| 8500.00 |
| 10000.00 |
+----------+SQL-결과 정렬
SQL ORDER BY절은 하나 이상의 열을 기준으로 오름차순 또는 내림차순으로 데이터를 정렬하는 데 사용됩니다. 일부 데이터베이스는 기본적으로 쿼리 결과를 오름차순으로 정렬합니다.
통사론
결과를 오름차순 또는 내림차순으로 정렬하는 데 사용되는 ORDER BY 절의 기본 구문은 다음과 같습니다.
SELECT column-list
FROM table_name
[WHERE condition]
[ORDER BY column1, column2, .. columnN] [ASC | DESC];ORDER BY 절에서 둘 이상의 열을 사용할 수 있습니다. 정렬에 사용하는 열이 무엇이든 해당 열이 열 목록에 있어야합니다.
예
다음 레코드가있는 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 |
+----+----------+-----+-----------+----------+다음은 결과를 NAME 및 SALARY별로 오름차순으로 정렬하는 예입니다.
SQL> SELECT * FROM CUSTOMERS
ORDER BY NAME, SALARY;이것은 다음 결과를 생성합니다-
+----+----------+-----+-----------+----------+
| 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 |
+----+----------+-----+-----------+----------+다음 코드 블록에는 NAME을 기준으로 결과를 내림차순으로 정렬하는 예제가 있습니다.
SQL> SELECT * FROM CUSTOMERS
ORDER BY NAME DESC;이것은 다음 결과를 생성합니다-
+----+----------+-----+-----------+----------+
| 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 |
+----+----------+-----+-----------+----------+선호하는 순서로 행을 가져 오기 위해 사용되는 SELECT 쿼리는 다음과 같습니다.
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;이것은 다음 결과를 생성합니다-
+----+----------+-----+-----------+----------+
| 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 |
+----+----------+-----+-----------+----------+그러면 ADDRESS별로 고객이 정렬됩니다. ownoOrder우선 우선 순위를 지정하고 나머지 주소에 대해서는 자연스러운 순서를 따릅니다. 또한 나머지 주소는 알파벳 역순으로 정렬됩니다.
SQL-제약
제약 조건은 테이블의 데이터 열에 적용되는 규칙입니다. 테이블에 들어갈 수있는 데이터 유형을 제한하는 데 사용됩니다. 이것은 데이터베이스에있는 데이터의 정확성과 신뢰성을 보장합니다.
제약 조건은 열 수준 또는 테이블 수준 일 수 있습니다. 열 수준 제약 조건은 하나의 열에 만 적용되는 반면 테이블 수준 제약 조건은 전체 테이블에 적용됩니다.
다음은 SQL에서 가장 일반적으로 사용되는 제약 조건 중 일부입니다. 이러한 제약은 SQL-RDBMS 개념 장 에서 이미 논의 되었지만이 시점에서 수정할 가치가 있습니다.
NOT NULL Constraint- 열이 NULL 값을 가질 수 없도록합니다.
DEFAULT Constraint- 아무것도 지정되지 않은 경우 열에 대한 기본값을 제공합니다.
UNIQUE Constraint- 열의 모든 값이 다른지 확인합니다.
PRIMARY Key- 데이터베이스 테이블의 각 행 / 레코드를 고유하게 식별합니다.
FOREIGN Key- 주어진 데이터베이스 테이블에서 행 / 레코드를 고유하게 식별합니다.
CHECK 제약 조건 -CHECK 제약 조건은 열의 모든 값이 특정 조건을 충족하는지 확인합니다.
INDEX- 매우 빠르게 데이터베이스에서 데이터를 생성하고 검색하는 데 사용됩니다.
제약 조건은 CREATE TABLE 문으로 테이블을 만들 때 지정하거나 ALTER TABLE 문을 사용하여 테이블을 만든 후에도 제약 조건을 만들 수 있습니다.
제약 조건 삭제
정의한 제약 조건은 DROP CONSTRAINT 옵션과 함께 ALTER TABLE 명령을 사용하여 삭제할 수 있습니다.
예를 들어 EMPLOYEES 테이블에서 기본 키 제약 조건을 삭제하려면 다음 명령을 사용할 수 있습니다.
ALTER TABLE EMPLOYEES DROP CONSTRAINT EMPLOYEES_PK;일부 구현에서는 특정 제약 조건을 삭제하는 단축키를 제공 할 수 있습니다. 예를 들어 Oracle에서 테이블에 대한 기본 키 제약 조건을 삭제하려면 다음 명령을 사용할 수 있습니다.
ALTER TABLE EMPLOYEES DROP PRIMARY KEY;일부 구현에서는 제약 조건을 비활성화 할 수 있습니다. 데이터베이스에서 제약 조건을 영구적으로 삭제하는 대신 제약 조건을 일시적으로 비활성화 한 다음 나중에 활성화 할 수 있습니다.
무결성 제약
무결성 제약 조건은 관계형 데이터베이스에서 데이터의 정확성과 일관성을 보장하는 데 사용됩니다. 데이터 무결성은 참조 무결성 개념을 통해 관계형 데이터베이스에서 처리됩니다.
다음과 같은 역할을하는 많은 유형의 무결성 제약이 있습니다. Referential Integrity (RI). 이러한 제약에는 기본 키, 외래 키, 고유 제약 및 위에서 언급 한 기타 제약이 포함됩니다.
SQL-조인 사용
SQL Joins절은 데이터베이스에있는 둘 이상의 테이블에서 레코드를 결합하는 데 사용됩니다. JOIN은 각각에 공통된 값을 사용하여 두 테이블의 필드를 결합하는 수단입니다.
다음 두 테이블을 고려하십시오-
Table 1 − 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 |
+----+----------+-----+-----------+----------+Table 2 − ORDERS 테이블
+-----+---------------------+-------------+--------+
|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 |
+-----+---------------------+-------------+--------+이제 아래 표시된 것처럼 SELECT 문에서이 두 테이블을 조인하겠습니다.
SQL> SELECT ID, NAME, AGE, AMOUNT
FROM CUSTOMERS, ORDERS
WHERE CUSTOMERS.ID = ORDERS.CUSTOMER_ID;그러면 다음과 같은 결과가 생성됩니다.
+----+----------+-----+--------+
| ID | NAME | AGE | AMOUNT |
+----+----------+-----+--------+
| 3 | kaushik | 23 | 3000 |
| 3 | kaushik | 23 | 1500 |
| 2 | Khilan | 25 | 1560 |
| 4 | Chaitali | 25 | 2060 |
+----+----------+-----+--------+여기서 WHERE 절에서 조인이 수행되는 것이 눈에 띈다. =, <,>, <>, <=,> =,! =, BETWEEN, LIKE 및 NOT과 같은 여러 연산자를 사용하여 테이블을 조인 할 수 있습니다. 테이블을 결합하는 데 모두 사용할 수 있습니다. 그러나 가장 일반적인 연산자는 같음 기호입니다.
SQL에서 사용할 수있는 조인의 다른 유형이 있습니다-
INNER JOIN- 두 테이블에 일치하는 항목이 있으면 행을 반환합니다.
LEFT JOIN- 오른쪽 테이블에 일치하는 항목이없는 경우에도 왼쪽 테이블의 모든 행을 반환합니다.
RIGHT JOIN- 왼쪽 테이블에 일치하는 항목이없는 경우에도 오른쪽 테이블의 모든 행을 반환합니다.
FULL JOIN- 테이블 중 하나에 일치하는 항목이 있으면 행을 반환합니다.
SELF JOIN- 테이블이 두 테이블 인 것처럼 테이블을 자신에 조인하여 SQL 문에서 적어도 하나의 테이블 이름을 일시적으로 변경하는 데 사용됩니다.
CARTESIAN JOIN- 둘 이상의 조인 된 테이블에서 레코드 집합의 데카르트 곱을 반환합니다.
이제 이러한 각 조인에 대해 자세히 설명하겠습니다.
SQL-UNIONS CLAUSE
SQL UNION 절 / 연산자는 중복 행을 반환하지 않고 둘 이상의 SELECT 문의 결과를 결합하는 데 사용됩니다.
이 UNION 절을 사용하려면 각 SELECT 문에
- 선택한 동일한 수의 열
- 동일한 수의 열 표현식
- 동일한 데이터 유형 및
- 같은 순서로
그러나 길이가 같을 필요는 없습니다.
통사론
의 기본 구문 UNION 절은 다음과 같습니다-
SELECT column1 [, column2 ]
FROM table1 [, table2 ]
[WHERE condition]
UNION
SELECT column1 [, column2 ]
FROM table1 [, table2 ]
[WHERE condition]여기서 주어진 조건은 요구 사항에 따라 주어진 표현식이 될 수 있습니다.
예
다음 두 테이블을 고려하십시오.
Table 1 − 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 |
+----+----------+-----+-----------+----------+Table 2 − ORDERS 테이블은 다음과 같습니다.
+-----+---------------------+-------------+--------+
|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 |
+-----+---------------------+-------------+--------+이제 다음과 같이 SELECT 문에서이 두 테이블을 결합 해 보겠습니다.
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;이것은 다음 결과를 생성합니다-
+------+----------+--------+---------------------+
| 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 |
+------+----------+--------+---------------------+UNION ALL 조항
UNION ALL 연산자는 중복 행을 포함하여 두 개의 SELECT 문의 결과를 결합하는 데 사용됩니다.
UNION 절에 적용되는 동일한 규칙이 UNION ALL 연산자에 적용됩니다.
통사론
의 기본 구문 UNION ALL 다음과 같다.
SELECT column1 [, column2 ]
FROM table1 [, table2 ]
[WHERE condition]
UNION ALL
SELECT column1 [, column2 ]
FROM table1 [, table2 ]
[WHERE condition]여기서 주어진 조건은 요구 사항에 따라 주어진 표현식이 될 수 있습니다.
예
다음 두 테이블을 고려하십시오.
Table 1 − 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 |
+----+----------+-----+-----------+----------+Table 2 − ORDERS 테이블은 다음과 같습니다.
+-----+---------------------+-------------+--------+
|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 |
+-----+---------------------+-------------+--------+이제 다음과 같이 SELECT 문에서이 두 테이블을 결합 해 보겠습니다.
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;이것은 다음 결과를 생성합니다-
+------+----------+--------+---------------------+
| 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 |
+------+----------+--------+---------------------+UNION 절과 같은 두 개의 다른 절 (예 : 연산자)이 있습니다.
SQL INTERSECT 절 -이것은 두 개의 SELECT 문을 결합하는 데 사용되지만 두 번째 SELECT 문에있는 행과 동일한 첫 번째 SELECT 문에서만 행을 반환합니다.
SQL EXCEPT 절 -이것은 두 개의 SELECT 문을 결합하고 두 번째 SELECT 문에 의해 반환되지 않은 첫 번째 SELECT 문에서 행을 반환합니다.
SQL-NULL 값
SQL NULL결 측값을 나타내는 데 사용되는 용어입니다. 테이블의 NULL 값은 공백으로 표시되는 필드의 값입니다.
NULL 값이있는 필드는 값이없는 필드입니다. NULL 값은 0 값 또는 공백이 포함 된 필드와 다르다는 것을 이해하는 것이 매우 중요합니다.
통사론
기본 구문 NULL 테이블을 만드는 동안.
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)
);여기, NOT NULL열은 항상 주어진 데이터 유형의 명시 적 값을 허용해야 함을 나타냅니다. NOT NULL을 사용하지 않은 두 개의 열이 있는데, 이는 이러한 열이 NULL 일 수 있음을 의미합니다.
NULL 값이있는 필드는 레코드 생성 중에 비어있는 필드입니다.
예
NULL 값은 데이터를 선택할 때 문제를 일으킬 수 있습니다. 그러나 알 수없는 값을 다른 값과 비교할 때 결과는 항상 알 수 없으며 결과에 포함되지 않습니다. 당신은IS NULL 또는 IS NOT NULL 연산자는 NULL 값을 확인합니다.
아래와 같이 레코드가있는 다음 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 | |
| 7 | Muffy | 24 | Indore | |
+----+----------+-----+-----------+----------+이제 다음은 IS NOT NULL운영자.
SQL> SELECT ID, NAME, AGE, ADDRESS, SALARY
FROM CUSTOMERS
WHERE SALARY IS NOT NULL;이것은 다음 결과를 생성합니다-
+----+----------+-----+-----------+----------+
| 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 |
+----+----------+-----+-----------+----------+이제 다음은 IS NULL 운영자.
SQL> SELECT ID, NAME, AGE, ADDRESS, SALARY
FROM CUSTOMERS
WHERE SALARY IS NULL;이것은 다음 결과를 생성합니다-
+----+----------+-----+-----------+----------+
| ID | NAME | AGE | ADDRESS | SALARY |
+----+----------+-----+-----------+----------+
| 6 | Komal | 22 | MP | |
| 7 | Muffy | 24 | Indore | |
+----+----------+-----+-----------+----------+SQL-별칭 구문
다음과 같은 다른 이름을 지정하여 테이블 또는 열의 이름을 임시로 바꿀 수 있습니다. Alias. 테이블 별칭을 사용하면 특정 SQL 문에서 테이블 이름을 바꿀 수 있습니다. 이름 변경은 일시적인 변경이며 실제 테이블 이름은 데이터베이스에서 변경되지 않습니다. 열 별칭은 특정 SQL 쿼리를 위해 테이블의 열 이름을 바꾸는 데 사용됩니다.
통사론
의 기본 구문 table 별칭은 다음과 같습니다.
SELECT column1, column2....
FROM table_name AS alias_name
WHERE [condition];의 기본 구문 column 별칭은 다음과 같습니다.
SELECT column_name AS alias_name
FROM table_name
WHERE [condition];예
다음 두 테이블을 고려하십시오.
Table 1 − 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 |
+----+----------+-----+-----------+----------+Table 2 − ORDERS 테이블은 다음과 같습니다.
+-----+---------------------+-------------+--------+
|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 |
+-----+---------------------+-------------+--------+이제 다음 코드 블록은 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;그러면 다음과 같은 결과가 생성됩니다.
+----+----------+-----+--------+
| ID | NAME | AGE | AMOUNT |
+----+----------+-----+--------+
| 3 | kaushik | 23 | 3000 |
| 3 | kaushik | 23 | 1500 |
| 2 | Khilan | 25 | 1560 |
| 4 | Chaitali | 25 | 2060 |
+----+----------+-----+--------+다음은 column alias.
SQL> SELECT ID AS CUSTOMER_ID, NAME AS CUSTOMER_NAME
FROM CUSTOMERS
WHERE SALARY IS NOT NULL;그러면 다음과 같은 결과가 생성됩니다.
+-------------+---------------+
| CUSTOMER_ID | CUSTOMER_NAME |
+-------------+---------------+
| 1 | Ramesh |
| 2 | Khilan |
| 3 | kaushik |
| 4 | Chaitali |
| 5 | Hardik |
| 6 | Komal |
| 7 | Muffy |
+-------------+---------------+SQL-인덱스
인덱스는 special lookup tables데이터베이스 검색 엔진이 데이터 검색 속도를 높이는 데 사용할 수 있습니다. 간단히 말해 인덱스는 테이블의 데이터에 대한 포인터입니다. 데이터베이스의 색인은 책 뒷면의 색인과 매우 유사합니다.
예를 들어, 특정 주제에 대해 설명하는 책의 모든 페이지를 참조하려면 먼저 색인을 참조하십시오. 색인은 모든 주제를 알파벳순으로 나열한 다음 하나 이상의 특정 페이지 번호를 참조합니다.
색인은 속도 향상에 도움이됩니다. SELECT 쿼리 및 WHERE 하지만 데이터 입력 속도가 느려집니다. UPDATE 그리고 INSERT진술. 인덱스는 데이터에 영향을주지 않고 생성하거나 삭제할 수 있습니다.
색인 생성에는 CREATE INDEX 문을 사용하면 인덱스 이름을 지정하고, 테이블과 인덱싱 할 열을 지정하고, 인덱스가 오름차순인지 내림차순인지 여부를 나타낼 수 있습니다.
인덱스는 다음과 같이 고유 할 수도 있습니다. UNIQUE 제약 조건은 인덱스가 인덱스가있는 열 또는 열 조합에서 중복 항목을 방지한다는 점입니다.
CREATE INDEX 명령
의 기본 구문 CREATE INDEX 다음과 같다.
CREATE INDEX index_name ON table_name;단일 열 인덱스
단일 열 인덱스는 하나의 테이블 열만을 기반으로 생성됩니다. 기본 구문은 다음과 같습니다.
CREATE INDEX index_name
ON table_name (column_name);고유 인덱스
고유 인덱스는 성능뿐만 아니라 데이터 무결성에도 사용됩니다. 고유 인덱스는 테이블에 중복 값을 삽입 할 수 없습니다. 기본 구문은 다음과 같습니다.
CREATE UNIQUE INDEX index_name
on table_name (column_name);복합 색인
복합 색인은 테이블의 두 개 이상의 열에 대한 색인입니다. 기본 구문은 다음과 같습니다.
CREATE INDEX index_name
on table_name (column1, column2);단일 열 인덱스 또는 복합 인덱스를 만들 것인지 여부에 관계없이 쿼리의 WHERE 절에서 필터 조건으로 매우 자주 사용할 수있는 열을 고려하십시오.
열이 하나만 사용되는 경우 단일 열 인덱스를 선택해야합니다. WHERE 절에서 필터로 자주 사용되는 열이 두 개 이상있는 경우 복합 인덱스가 최선의 선택입니다.
암시 적 인덱스
암시 적 인덱스는 개체가 생성 될 때 데이터베이스 서버에서 자동으로 생성되는 인덱스입니다. 기본 키 제약 조건 및 고유 제약 조건에 대해 인덱스가 자동으로 생성됩니다.
DROP INDEX 명령
SQL을 사용하여 인덱스를 삭제할 수 있습니다. DROP명령. 성능이 느려지거나 향상 될 수 있으므로 인덱스를 삭제할 때주의해야합니다.
기본 구문은 다음과 같습니다.
DROP INDEX index_name;INDEX Constraint 장에서 인덱스에 대한 실제 예제를 볼 수 있습니다 .
인덱스는 언제 피해야합니까?
인덱스는 데이터베이스의 성능을 향상시키기위한 것이지만 피해야하는 경우가 있습니다.
다음 지침은 인덱스 사용을 재고해야하는시기를 나타냅니다.
작은 테이블에는 인덱스를 사용하면 안됩니다.
대규모 일괄 업데이트 또는 삽입 작업이 빈번한 테이블.
많은 수의 NULL 값을 포함하는 열에는 인덱스를 사용하면 안됩니다.
자주 조작되는 열은 인덱싱하지 않아야합니다.
SQL-ALTER TABLE 명령
SQL ALTER TABLE명령은 기존 테이블에서 열을 추가, 삭제 또는 수정하는 데 사용됩니다. 또한 ALTER TABLE 명령을 사용하여 기존 테이블에 다양한 제약 조건을 추가 및 삭제해야합니다.
통사론
ALTER TABLE 명령의 기본 구문은 New Column 기존 테이블에서 다음과 같습니다.
ALTER TABLE table_name ADD column_name datatype;ALTER TABLE 명령의 기본 구문 DROP COLUMN 기존 테이블에서 다음과 같습니다.
ALTER TABLE table_name DROP COLUMN column_name;ALTER TABLE 명령의 기본 구문은 DATA TYPE 테이블의 열의 개수는 다음과 같습니다.
ALTER TABLE table_name MODIFY COLUMN column_name datatype;ALTER TABLE 명령의 기본 구문은 NOT NULL 테이블의 컬럼에 대한 제약은 다음과 같습니다.
ALTER TABLE table_name MODIFY column_name datatype NOT NULL;ALTER TABLE의 기본 구문은 ADD UNIQUE CONSTRAINT 테이블에 다음과 같습니다.
ALTER TABLE table_name
ADD CONSTRAINT MyUniqueConstraint UNIQUE(column1, column2...);ALTER TABLE 명령의 기본 구문 ADD CHECK CONSTRAINT 테이블에 다음과 같습니다.
ALTER TABLE table_name
ADD CONSTRAINT MyUniqueConstraint CHECK (CONDITION);ALTER TABLE 명령의 기본 구문 ADD PRIMARY KEY 테이블에 대한 제약은 다음과 같습니다.
ALTER TABLE table_name
ADD CONSTRAINT MyPrimaryKey PRIMARY KEY (column1, column2...);ALTER TABLE 명령의 기본 구문 DROP CONSTRAINT 표에서 다음과 같습니다.
ALTER TABLE table_name
DROP CONSTRAINT MyUniqueConstraint;MySQL을 사용하는 경우 코드는 다음과 같습니다.
ALTER TABLE table_name
DROP INDEX MyUniqueConstraint;ALTER TABLE 명령의 기본 구문 DROP PRIMARY KEY 테이블의 제약은 다음과 같습니다.
ALTER TABLE table_name
DROP CONSTRAINT MyPrimaryKey;MySQL을 사용하는 경우 코드는 다음과 같습니다.
ALTER TABLE table_name
DROP PRIMARY KEY;예
다음 레코드가있는 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 |
+----+----------+-----+-----------+----------+다음은 추가하는 예입니다. New Column 기존 테이블에-
ALTER TABLE CUSTOMERS ADD SEX char(1);이제 CUSTOMERS 테이블이 변경되고 SELECT 문에서 다음과 같이 출력됩니다.
+----+---------+-----+-----------+----------+------+
| 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 |
+----+---------+-----+-----------+----------+------+다음은 기존 테이블에서 sex 컬럼을 DROP하는 예입니다.
ALTER TABLE CUSTOMERS DROP SEX;이제 CUSTOMERS 테이블이 변경되고 다음은 SELECT 문의 출력입니다.
+----+---------+-----+-----------+----------+
| 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-TRUNCATE TABLE 명령
SQL TRUNCATE TABLE 명령은 기존 테이블에서 완전한 데이터를 삭제하는 데 사용됩니다.
DROP TABLE 명령을 사용하여 전체 테이블을 삭제할 수도 있지만 데이터베이스에서 전체 테이블 구조를 제거하므로 일부 데이터를 저장하려면이 테이블을 다시 만들어야합니다.
통사론
의 기본 구문 TRUNCATE TABLE 명령은 다음과 같습니다.
TRUNCATE TABLE table_name;예
다음 레코드가있는 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 |
+----+----------+-----+-----------+----------+다음은 Truncate 명령의 예입니다.
SQL > TRUNCATE TABLE CUSTOMERS;이제 CUSTOMERS 테이블이 잘리고 SELECT 문의 출력은 아래 코드 블록과 같습니다.
SQL> SELECT * FROM CUSTOMERS;
Empty set (0.00 sec)SQL-보기 사용
뷰는 연관된 이름으로 데이터베이스에 저장된 SQL 문에 불과합니다. 뷰는 실제로 미리 정의 된 SQL 쿼리 형식의 테이블 구성입니다.
뷰는 테이블의 모든 행을 포함하거나 테이블에서 행을 선택할 수 있습니다. 뷰를 생성하기 위해 작성된 SQL 쿼리에 의존하는 하나 이상의 테이블에서 뷰를 생성 할 수 있습니다.
가상 테이블의 유형 인보기는 사용자가 다음을 수행 할 수 있도록합니다.
사용자 또는 사용자 클래스가 자연 스럽거나 직관적 인 방식으로 데이터를 구조화합니다.
사용자가 필요로하는 것을 정확히보고 수정할 수 있도록 데이터에 대한 액세스를 제한합니다.
보고서를 생성하는 데 사용할 수있는 다양한 테이블의 데이터를 요약합니다.
보기 만들기
데이터베이스보기는 CREATE VIEW성명서. 뷰는 단일 테이블, 여러 테이블 또는 다른 뷰에서 만들 수 있습니다.
보기를 만들려면 사용자에게 특정 구현에 따라 적절한 시스템 권한이 있어야합니다.
기본 CREATE VIEW 구문은 다음과 같습니다-
CREATE VIEW view_name AS
SELECT column1, column2.....
FROM table_name
WHERE [condition];일반 SQL SELECT 쿼리에서 사용하는 것과 유사한 방식으로 SELECT 문에 여러 테이블을 포함 할 수 있습니다.
예
다음 레코드가있는 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 |
+----+----------+-----+-----------+----------+다음은 CUSTOMERS 테이블에서보기를 작성하는 예입니다. 이 뷰는 CUSTOMERS 테이블에서 고객 이름과 나이를 갖는 데 사용됩니다.
SQL > CREATE VIEW CUSTOMERS_VIEW AS
SELECT name, age
FROM CUSTOMERS;이제 실제 테이블을 쿼리하는 것과 유사한 방식으로 CUSTOMERS_VIEW를 쿼리 할 수 있습니다. 다음은 동일한 예입니다.
SQL > SELECT * FROM CUSTOMERS_VIEW;그러면 다음과 같은 결과가 생성됩니다.
+----------+-----+
| name | age |
+----------+-----+
| Ramesh | 32 |
| Khilan | 25 |
| kaushik | 23 |
| Chaitali | 25 |
| Hardik | 27 |
| Komal | 22 |
| Muffy | 24 |
+----------+-----+WITH CHECK 옵션
WITH CHECK OPTION은 CREATE VIEW 문 옵션입니다. WITH CHECK OPTION의 목적은 모든 UPDATE 및 INSERT가 뷰 정의의 조건을 충족하는지 확인하는 것입니다.
조건을 만족하지 않으면 UPDATE 또는 INSERT가 오류를 반환합니다.
다음 코드 블록에는 WITH CHECK OPTION을 사용하여 동일한 뷰 CUSTOMERS_VIEW를 생성하는 예가 있습니다.
CREATE VIEW CUSTOMERS_VIEW AS
SELECT name, age
FROM CUSTOMERS
WHERE age IS NOT NULL
WITH CHECK OPTION;이 경우 WITH CHECK OPTION은 뷰가 AGE 열에 NULL 값이없는 데이터로 정의되기 때문에 뷰의 AGE 열에있는 모든 NULL 값의 입력을 거부해야합니다.
보기 업데이트
아래에 주어진 특정 조건에서보기를 업데이트 할 수 있습니다.
SELECT 절은 키워드 DISTINCT를 포함 할 수 없습니다.
SELECT 절에는 요약 함수가 포함될 수 없습니다.
SELECT 절에는 집합 함수가 포함될 수 없습니다.
SELECT 절에는 집합 연산자가 포함될 수 없습니다.
SELECT 절에는 ORDER BY 절이 포함될 수 없습니다.
FROM 절은 여러 테이블을 포함 할 수 없습니다.
WHERE 절에는 하위 쿼리가 포함될 수 없습니다.
쿼리에 GROUP BY 또는 HAVING이 포함될 수 없습니다.
계산 된 열은 업데이트 할 수 없습니다.
INSERT 쿼리가 작동하려면 기본 테이블의 모든 NOT NULL 열이 뷰에 포함되어야합니다.
따라서보기가 위에서 언급 한 모든 규칙을 충족하면 해당보기를 업데이트 할 수 있습니다. 다음 코드 블록에는 Ramesh의 나이를 업데이트하는 예제가 있습니다.
SQL > UPDATE CUSTOMERS_VIEW
SET AGE = 35
WHERE name = 'Ramesh';이것은 궁극적으로 기본 테이블 CUSTOMERS를 업데이트하고 동일한 내용이 뷰 자체에 반영됩니다. 이제 기본 테이블을 쿼리하면 SELECT 문이 다음 결과를 생성합니다.
+----+----------+-----+-----------+----------+
| 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 |
+----+----------+-----+-----------+----------+뷰에 행 삽입
데이터 행을 뷰에 삽입 할 수 있습니다. UPDATE 명령에 적용되는 동일한 규칙이 INSERT 명령에도 적용됩니다.
여기서는이 뷰에 NOT NULL 열을 모두 포함하지 않았기 때문에 CUSTOMERS_VIEW에 행을 삽입 할 수 없습니다. 그렇지 않으면 테이블에 삽입하는 것과 유사한 방식으로 뷰에 행을 삽입 할 수 있습니다.
보기로 행 삭제
보기에서 데이터 행을 삭제할 수 있습니다. UPDATE 및 INSERT 명령에 적용되는 동일한 규칙이 DELETE 명령에 적용됩니다.
다음은 AGE = 22 인 레코드를 삭제하는 예입니다.
SQL > DELETE FROM CUSTOMERS_VIEW
WHERE age = 22;이것은 궁극적으로 기본 테이블 CUSTOMERS에서 행을 삭제하고 동일한 내용이 뷰 자체에 반영됩니다. 이제 기본 테이블을 쿼리하면 SELECT 문이 다음 결과를 생성합니다.
+----+----------+-----+-----------+----------+
| 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 |
+----+----------+-----+-----------+----------+뷰 삭제
분명히 뷰가있는 곳에서 더 이상 필요하지 않은 경우 뷰를 삭제할 수있는 방법이 필요합니다. 구문은 매우 간단하며 아래에 나와 있습니다.
DROP VIEW view_name;다음은 CUSTOMERS 테이블에서 CUSTOMERS_VIEW를 삭제하는 예입니다.
DROP VIEW CUSTOMERS_VIEW;SQL-절 포함
그만큼 HAVING Clause 결과에 나타나는 그룹 결과를 필터링하는 조건을 지정할 수 있습니다.
WHERE 절은 선택한 열에 조건을 배치하는 반면 HAVING 절은 GROUP BY 절에 의해 생성 된 그룹에 조건을 배치합니다.
통사론
다음 코드 블록은 쿼리에서 HAVING 절의 위치를 보여줍니다.
SELECT
FROM
WHERE
GROUP BY
HAVING
ORDER BYHAVING 절은 쿼리에서 GROUP BY 절 뒤에 와야하며 사용되는 경우 ORDER BY 절 앞에 와야합니다. 다음 코드 블록에는 HAVING 절을 포함하는 SELECT 문의 구문이 있습니다.
SELECT column1, column2
FROM table1, table2
WHERE [ conditions ]
GROUP BY column1, column2
HAVING [ conditions ]
ORDER BY column1, column2예
다음 레코드가있는 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 |
+----+----------+-----+-----------+----------+다음은 2보다 크거나 같은 유사한 연령 계수에 대한 레코드를 표시하는 예입니다.
SQL > SELECT ID, NAME, AGE, ADDRESS, SALARY
FROM CUSTOMERS
GROUP BY age
HAVING COUNT(age) >= 2;이것은 다음 결과를 생성합니다-
+----+--------+-----+---------+---------+
| ID | NAME | AGE | ADDRESS | SALARY |
+----+--------+-----+---------+---------+
| 2 | Khilan | 25 | Delhi | 1500.00 |
+----+--------+-----+---------+---------+SQL-트랜잭션
트랜잭션은 데이터베이스에 대해 수행되는 작업 단위입니다. 트랜잭션은 사용자가 수동으로 수행하든 또는 일종의 데이터베이스 프로그램에 의해 자동으로 수행 되든 논리적 순서로 수행되는 작업 단위 또는 시퀀스입니다.
트랜잭션은 데이터베이스에 대한 하나 이상의 변경 사항을 전파하는 것입니다. 예를 들어 레코드를 만들거나 레코드를 업데이트하거나 테이블에서 레코드를 삭제하는 경우 해당 테이블에서 트랜잭션을 수행하는 것입니다. 데이터 무결성을 보장하고 데이터베이스 오류를 처리하려면 이러한 트랜잭션을 제어하는 것이 중요합니다.
실제로 많은 SQL 쿼리를 그룹으로 묶고 트랜잭션의 일부로 모두 함께 실행합니다.
거래의 속성
트랜잭션에는 일반적으로 약어로 참조되는 다음 네 가지 표준 속성이 있습니다. ACID.
Atomicity− 작업 단위 내의 모든 작업이 성공적으로 완료되었는지 확인합니다. 그렇지 않으면 트랜잭션이 실패 지점에서 중단되고 모든 이전 작업이 이전 상태로 롤백됩니다.
Consistency − 성공적으로 커밋 된 트랜잭션에서 데이터베이스가 상태를 적절하게 변경하는지 확인합니다.
Isolation − 거래가 서로 독립적이고 투명하게 운영 될 수 있도록합니다.
Durability − 시스템 장애시 커밋 된 트랜잭션의 결과 또는 효과가 지속되도록합니다.
거래 통제
다음 명령은 트랜잭션을 제어하는 데 사용됩니다.
COMMIT − 변경 사항을 저장합니다.
ROLLBACK − 변경 사항을 롤백합니다.
SAVEPOINT − ROLLBACK 할 트랜잭션 그룹 내에서 포인트를 생성합니다.
SET TRANSACTION − 거래에 이름을 붙입니다.
트랜잭션 제어 명령
트랜잭션 제어 명령은 DML Commands예 : INSERT, UPDATE 및 DELETE 만. 이러한 작업은 데이터베이스에서 자동으로 커밋되기 때문에 테이블을 생성하거나 삭제하는 동안에는 사용할 수 없습니다.
COMMIT 명령
COMMIT 명령은 트랜잭션에 의해 호출 된 변경 사항을 데이터베이스에 저장하는 데 사용되는 트랜잭션 명령입니다.
COMMIT 명령은 트랜잭션에 의해 호출 된 변경 사항을 데이터베이스에 저장하는 데 사용되는 트랜잭션 명령입니다. COMMIT 명령은 마지막 COMMIT 또는 ROLLBACK 명령 이후 모든 트랜잭션을 데이터베이스에 저장합니다.
COMMIT 명령 구문은 다음과 같습니다.
COMMIT;Example
다음 레코드가있는 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 |
+----+----------+-----+-----------+----------+다음은 age = 25 인 테이블에서 해당 레코드를 삭제 한 다음 데이터베이스에서 변경 사항을 커밋하는 예제입니다.
SQL> DELETE FROM CUSTOMERS
WHERE AGE = 25;
SQL> COMMIT;따라서 테이블에서 두 행이 삭제되고 SELECT 문이 다음 결과를 생성합니다.
+----+----------+-----+-----------+----------+
| 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 |
+----+----------+-----+-----------+----------+ROLLBACK 명령
ROLLBACK 명령은 데이터베이스에 아직 저장되지 않은 트랜잭션을 실행 취소하는 데 사용되는 트랜잭션 명령입니다. 이 명령은 마지막 COMMIT 또는 ROLLBACK 명령이 발행 된 이후 트랜잭션을 실행 취소하는 데만 사용할 수 있습니다.
ROLLBACK 명령의 구문은 다음과 같습니다.
ROLLBACK;Example
다음 레코드가있는 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 |
+----+----------+-----+-----------+----------+다음은 연령 = 25 인 테이블에서 해당 레코드를 삭제 한 다음 데이터베이스의 변경 사항을 ROLLBACK하는 예입니다.
SQL> DELETE FROM CUSTOMERS
WHERE AGE = 25;
SQL> ROLLBACK;따라서 삭제 작업은 테이블에 영향을주지 않으며 SELECT 문은 다음 결과를 생성합니다.
+----+----------+-----+-----------+----------+
| 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 |
+----+----------+-----+-----------+----------+SAVEPOINT 명령
SAVEPOINT는 전체 트랜잭션을 롤백하지 않고 특정 지점으로 트랜잭션을 롤백 할 수있는 트랜잭션의 지점입니다.
SAVEPOINT 명령의 구문은 다음과 같습니다.
SAVEPOINT SAVEPOINT_NAME;이 명령은 모든 트랜잭션 문 중에서 SAVEPOINT를 만드는 데만 사용됩니다. ROLLBACK 명령은 트랜잭션 그룹을 실행 취소하는 데 사용됩니다.
SAVEPOINT로 롤백하는 구문은 다음과 같습니다.
ROLLBACK TO SAVEPOINT_NAME;다음은 CUSTOMERS 테이블에서 세 가지 다른 레코드를 삭제하려는 예입니다. 삭제할 때마다 SAVEPOINT를 생성하여 언제든지 SAVEPOINT로 ROLLBACK하여 적절한 데이터를 원래 상태로 되돌릴 수 있습니다.
Example
다음 레코드가있는 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 |
+----+----------+-----+-----------+----------+다음 코드 블록에는 일련의 작업이 포함되어 있습니다.
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.이제 세 가지 삭제가 수행되었으므로 마음이 바뀌었고 SP2로 식별 한 SAVEPOINT로 롤백하기로 결정했다고 가정하겠습니다. SP2는 첫 번째 삭제 후 생성되었으므로 마지막 두 삭제는 취소됩니다.
SQL> ROLLBACK TO SP2;
Rollback complete.SP2로 롤백 한 이후 첫 번째 삭제 만 발생했습니다.
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.RELEASE SAVEPOINT 명령
RELEASE SAVEPOINT 명령은 작성한 SAVEPOINT를 제거하는 데 사용됩니다.
RELEASE SAVEPOINT 명령의 구문은 다음과 같습니다.
RELEASE SAVEPOINT SAVEPOINT_NAME;SAVEPOINT가 해제되면 더 이상 ROLLBACK 명령을 사용하여 마지막 SAVEPOINT 이후 수행 된 트랜잭션을 실행 취소 할 수 없습니다.
SET TRANSACTION 명령
SET TRANSACTION 명령을 사용하여 데이터베이스 트랜잭션을 시작할 수 있습니다. 이 명령은 다음 트랜잭션의 특성을 지정하는 데 사용됩니다. 예를 들어 트랜잭션을 읽기 전용 또는 읽기 쓰기로 지정할 수 있습니다.
SET TRANSACTION 명령의 구문은 다음과 같습니다.
SET TRANSACTION [ READ WRITE | READ ONLY ];SQL-와일드 카드 연산자
와일드 카드 연산자를 사용하여 값을 유사한 값과 비교하는 데 사용되는 SQL LIKE 연산자에 대해 이미 논의했습니다.
SQL은 다음 표에서 자세히 설명하는 LIKE 연산자와 함께 두 개의 와일드 카드 연산자를 지원합니다.
| Sr. 아니. | 와일드 카드 및 설명 |
|---|---|
| 1 | The percent sign (%) 하나 이상의 문자와 일치합니다. Note − MS Access는 퍼센트 기호 (%) 와일드 카드 문자 대신 별표 (*) 와일드 카드 문자를 사용합니다. |
| 2 | The underscore (_) 한 문자와 일치합니다. Note − MS Access는 하나의 문자와 일치하기 위해 밑줄 (_) 대신 물음표 (?)를 사용합니다. |
퍼센트 기호는 0 개, 1 개 또는 여러 문자를 나타냅니다. 밑줄은 단일 숫자 또는 문자를 나타냅니다. 이러한 기호는 조합하여 사용할 수 있습니다.
통사론
'%'및 '_'연산자의 기본 구문은 다음과 같습니다.
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_'AND 또는 OR 연산자를 사용하여 N 개의 조건을 결합 할 수 있습니다. 여기서 XXXX는 숫자 또는 문자열 값이 될 수 있습니다.
예
다음 표에는 '%'및 '_'연산자가있는 서로 다른 LIKE 절이있는 WHERE 부분을 보여주는 여러 예제가 있습니다.
| Sr. 아니. | 성명 및 설명 |
|---|---|
| 1 | WHERE SALARY LIKE '200%' 200으로 시작하는 모든 값을 찾습니다. |
| 2 | WHERE SALARY LIKE '%200%' 임의의 위치에 200이있는 모든 값을 찾습니다. |
| 삼 | WHERE SALARY LIKE '_00%' 두 번째 및 세 번째 위치에 00이있는 모든 값을 찾습니다. |
| 4 | WHERE SALARY LIKE '2_%_%' 2로 시작하고 길이가 3 자 이상인 모든 값을 찾습니다. |
| 5 | WHERE SALARY LIKE '%2' 2로 끝나는 모든 값을 찾습니다. |
| 6 | WHERE SALARY LIKE '_2%3' 두 번째 위치에 2가 있고 3으로 끝나는 값을 찾습니다. |
| 7 | WHERE SALARY LIKE '2___3' 2로 시작하고 3으로 끝나는 5 자리 숫자의 값을 찾습니다. |
실제 예를 들어 다음 레코드가있는 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 |
+----+----------+-----+-----------+----------+다음 코드 블록은 SALARY가 200으로 시작하는 CUSTOMERS 테이블의 모든 레코드를 표시하는 예제입니다.
SQL> SELECT * FROM CUSTOMERS
WHERE SALARY LIKE '200%';그러면 다음과 같은 결과가 생성됩니다.
+----+----------+-----+-----------+----------+
| ID | NAME | AGE | ADDRESS | SALARY |
+----+----------+-----+-----------+----------+
| 1 | Ramesh | 32 | Ahmedabad | 2000.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
+----+----------+-----+-----------+----------+SQL-날짜 함수
다음 표에는 SQL을 통해 사용할 수있는 모든 중요한 날짜 및 시간 관련 함수 목록이 있습니다. RDBMS에서 지원하는 다양한 기타 기능이 있습니다. 주어진 목록은 MySQL RDBMS를 기반으로합니다.
| Sr. 아니. | 기능 및 설명 |
|---|---|
| 1 | ADDDATE () 날짜 추가 |
| 2 | ADDTIME () 시간 추가 |
| 삼 | CONVERT_TZ () 한 시간대에서 다른 시간대로 변환 |
| 4 | CURDATE () 현재 날짜를 반환합니다. |
| 5 | CURRENT_DATE (), CURRENT_DATE CURDATE ()의 동의어 |
| 6 | CURRENT_TIME (), CURRENT_TIME CURTIME ()의 동의어 |
| 7 | CURRENT_TIMESTAMP (), CURRENT_TIMESTAMP NOW ()의 동의어 |
| 8 | CURTIME () 현재 시간을 반환합니다. |
| 9 | DATE_ADD () 두 개의 날짜를 추가합니다. |
| 10 | 날짜 형식() 지정된대로 날짜 형식 지정 |
| 11 | DATE_SUB () 두 날짜를 뺍니다. |
| 12 | 데이트() 날짜 또는 날짜 시간 식의 날짜 부분을 추출합니다. |
| 13 | DATEDIFF () 두 날짜를 뺍니다. |
| 14 | 일() DAYOFMONTH ()의 동의어 |
| 15 | DAYNAME () 요일의 이름을 반환합니다. |
| 16 | DAYOFMONTH () 날짜 (1-31)를 반환합니다. |
| 17 | DAYOFWEEK () 인수의 요일 인덱스를 반환합니다. |
| 18 | DAYOFYEAR () 연중 일 (1-366)을 반환합니다. |
| 19 | 추출물 날짜의 일부 추출 |
| 20 | FROM_DAYS () 일 숫자를 날짜로 변환 |
| 21 | FROM_UNIXTIME () UNIX 타임 스탬프로 날짜 형식 지정 |
| 22 | 시() 시간 추출 |
| 23 | 마지막 날 인수의 마지막 날을 반환합니다. |
| 24 | LOCALTIME (), LOCALTIME NOW ()의 동의어 |
| 25 | LOCALTIMESTAMP, LOCALTIMESTAMP () NOW ()의 동의어 |
| 26 | 메이크 데이트 () 연도와 연도에서 날짜를 만듭니다. |
| 27 | 시간을 내다 시간을 내다() |
| 28 | MICROSECOND () 인수에서 마이크로 초를 반환합니다. |
| 29 | 분() 인수에서 분을 반환합니다. |
| 30 | 달() 지난 날짜로부터 월을 반환 |
| 31 | MONTHNAME () 월의 이름을 반환합니다. |
| 32 | 지금() 현재 날짜와 시간을 반환합니다. |
| 33 | PERIOD_ADD () 1 년-월에 기간을 추가합니다. |
| 34 | PERIOD_DIFF () 기간 사이의 개월 수를 반환합니다. |
| 35 | 쿼터() 날짜 인수에서 분기를 반환합니다. |
| 36 | SEC_TO_TIME () 초를 'HH : MM : SS'형식으로 변환합니다. |
| 37 | 둘째() 초를 반환합니다 (0-59). |
| 38 | STR_TO_DATE () 문자열을 날짜로 변환 |
| 39 | SUBDATE () 세 개의 인수로 호출 될 때 DATE_SUB ()의 동의어 |
| 40 | SUBTIME () 시간을 뺍니다 |
| 41 | SYSDATE () 함수가 실행되는 시간을 반환합니다. |
| 42 | 시간 형식() 시간 형식 |
| 43 | TIME_TO_SEC () 초로 변환 된 인수를 반환합니다. |
| 44 | 시각() 전달 된 표현식의 시간 부분을 추출합니다. |
| 45 | TIMEDIFF () 시간을 뺍니다 |
| 46 | TIMESTAMP () 단일 인수를 사용하여이 함수는 날짜 또는 날짜 시간 표현식을 반환합니다. 두 개의 인수를 사용하면 인수의 합이 |
| 47 | TIMESTAMPADD () datetime 식에 간격을 추가합니다. |
| 48 | TIMESTAMPDIFF () datetime 식에서 간격을 뺍니다. |
| 49 | TO_DAYS () 일로 변환 된 날짜 인수를 반환합니다. |
| 50 | UNIX_TIMESTAMP () UNIX 타임 스탬프를 반환합니다. |
| 51 | UTC_DATE () 현재 UTC 날짜를 반환합니다. |
| 52 | UTC_TIME () 현재 UTC 시간을 반환합니다. |
| 53 | UTC_TIMESTAMP () 현재 UTC 날짜 및 시간을 반환합니다. |
| 54 | 주() 주 번호를 반환합니다. |
| 55 | 주일() 요일 인덱스를 반환합니다. |
| 56 | WEEKOFYEAR () 날짜의 달력 주 (1-53)를 반환합니다. |
| 57 | 년() 연도를 반환합니다. |
| 58 | YEARWEEK () 연도와 주를 반환합니다. |
ADDDATE (날짜, INTERVAL expr 단위), ADDDATE (expr, days)
두 번째 인수의 INTERVAL 형식으로 호출하면 ADDDATE ()는 DATE_ADD ()의 동의어입니다. 관련 함수 SUBDATE ()는 DATE_SUB ()의 동의어입니다. INTERVAL 단위 인수에 대한 정보는 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)두 번째 인수의 days 형식으로 호출되면 MySQL은이를 expr에 추가 할 정수 일 수로 처리합니다.
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 (expr1, expr2)
ADDTIME ()은 expr2를 expr1에 추가하고 결과를 반환합니다. expr1은 시간 또는 datetime 표현식이고 expr2는 시간 표현식입니다.
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)
이것은 from_tz에 의해 제공된 시간대에서 to_tz에 의해 제공된 시간대로 datetime 값 dt를 변환하고 결과 값을 리턴합니다. 이 함수는 인수가 유효하지 않은 경우 NULL을 반환합니다.
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 ()
함수가 문자열 또는 숫자 컨텍스트에서 사용되는지 여부에 따라 현재 날짜를 'YYYY-MM-DD'또는 YYYYMMDD 형식의 값으로 반환합니다.
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 및 CURRENT_DATE ()
CURRENT_DATE 및 CURRENT_DATE ()는 CURDATE ()의 동의어입니다.
CURTIME ()
함수가 문자열 또는 숫자 컨텍스트에서 사용되는지 여부에 따라 현재 시간을 'HH : MM : SS'또는 HHMMSS 형식의 값으로 반환합니다. 값은 현재 시간대로 표시됩니다.
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 및 CURRENT_TIME ()
CURRENT_TIME 및 CURRENT_TIME ()은 CURTIME ()의 동의어입니다.
CURRENT_TIMESTAMP 및 CURRENT_TIMESTAMP ()
CURRENT_TIMESTAMP 및 CURRENT_TIMESTAMP ()는 NOW ()의 동의어입니다.
DATE (expr)
날짜 또는 날짜 시간 표현식 expr의 날짜 부분을 추출합니다.
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 (expr1, expr2)
DATEDIFF ()는 expr1을 반환합니다. expr2는 한 날짜에서 다른 날짜까지의 일 값으로 표현됩니다. expr1 및 expr2는 모두 날짜 또는 날짜 및 시간 표현식입니다. 값의 날짜 부분 만 계산에 사용됩니다.
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 (날짜, INTERVAL expr 단위), DATE_SUB (date, INTERVAL expr 단위)
이 함수는 날짜 산술을 수행합니다. 그만큼date시작 날짜를 지정하는 DATETIME 또는 DATE 값입니다. 그만큼expr시작 날짜에서 더하거나 뺄 간격 값을 지정하는 표현식입니다. expr은 문자열입니다. 음수 간격의 경우 '-'로 시작할 수 있습니다.
ㅏ unit 식이 해석되어야하는 단위를 나타내는 키워드입니다.
그만큼 INTERVAL 키워드 및 단위 지정자는 대소 문자를 구분하지 않습니다.
다음 표는 각 단위 값에 대한 expr 인수의 예상 형식을 보여줍니다.
| 단위 값 | exprFormat 예상 |
|---|---|
| MICROSECOND | 마이크로 초 |
| 둘째 | SECONDS |
| 분 | 의사록 |
| 시 | 시간 |
| 일 | 일 |
| 주 | 주 |
| 달 | 개월 |
| 쿼터 | 병사 |
| 년 | 연령 |
| SECOND_MICROSECOND | 'SECONDS.MICROSECONDS' |
| MINUTE_MICROSECOND | 'MINUTES.MICROSECONDS' |
| MINUTE_SECOND | 'MINUTES : SECONDS' |
| HOUR_MICROSECOND | 'HOURS.MICROSECONDS' |
| HOUR_SECOND | 'HOURS : MINUTES : SECONDS' |
| HOUR_MINUTE | 'HOURS : MINUTES' |
| DAY_MICROSECOND | 'DAYS.MICROSECONDS' |
| DAY_SECOND | 'DAYS HOURS : MINUTES : SECONDS' |
| DAY_MINUTE | 'DAYS HOURS : MINUTES' |
| DAY_HOUR | 'DAYS HOURS' |
| YEAR_MONTH | '년-개월' |
가치 QUARTER 과 WEEKMySQL 5.0.0에서 사용할 수 있습니다. 버전.
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 (날짜, 형식)
이 명령은 형식 문자열에 따라 날짜 값을 형식화합니다.
다음 지정자는 형식 문자열에 사용될 수 있습니다. 형식 지정자 문자 앞에 '%'문자가 필요합니다.
| Sr. 아니. | 지정자 및 설명 |
|---|---|
| 1 | %a 축약 된 요일 이름 (일 .. 토) |
| 2 | %b 약식 월 이름 (Jan..Dec) |
| 삼 | %c 월, 숫자 (0..12) |
| 4 | %D 영어 접미사가있는 날짜 (0 일, 1 일, 2 일, 3 일,.) |
| 5 | %d 날짜, 숫자 (00..31) |
| 6 | %e 날짜, 숫자 (0..31) |
| 7 | %f 마이크로 초 (000000..999999) |
| 8 | %H 시간 (00..23) |
| 9 | %h 시간 (01..12) |
| 10 | %I 시간 (01..12) |
| 11 | %i 분, 숫자 (00..59) |
| 12 | %j 연중 일 (001..366) |
| 13 | %k 시간 (0..23) |
| 14 | %l 시간 (1..12) |
| 15 | %M 월 이름 (January..December) |
| 16 | %m 월, 숫자 (00..12) |
| 17 | %p 오전 아니면 오후 |
| 18 | %r 시간, 12 시간 (hh : mm : ss 뒤에 AM 또는 PM) |
| 19 | %S 초 (00..59) |
| 20 | %s 초 (00..59) |
| 21 | %T 시간, 24 시간 (hh : mm : ss) |
| 22 | %U 주 (00..53), 여기서 일요일은 요일입니다. |
| 23 | %u 주 (00..53), 여기서 월요일은 한주의 첫 번째 날입니다. |
| 24 | %V 주 (01..53), 여기서 일요일은 요일입니다. % X와 함께 사용 |
| 25 | %v 주 (01..53). 여기서 월요일은 한주의 첫 날입니다. % x와 함께 사용 |
| 26 | %W 요일 이름 (일요일 .. 토요일) |
| 27 | %w 요일 (0 = 일요일 ..6 = 토요일) |
| 28 | %X 일요일이 요일 인 숫자, 4 자리 인주의 연도입니다. % V와 함께 사용 |
| 29 | %x 한주의 연도. 여기서 월요일은 한주의 첫 번째 요일이며 숫자 4 자리입니다. % v와 함께 사용 |
| 30 | %Y 연도, 숫자, 4 자리 |
| 31 | %y 연도, 숫자 (2 자리) |
| 32 | %% 리터럴. %. 캐릭터 |
| 33 | %x x, any.x. 위에 나열되지 않음 |
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 (날짜, INTERVAL expr 단위)
이것은 DATE_ADD () 함수와 유사합니다.
DAY (날짜)
DAY ()는 DAYOFMONTH () 함수의 동의어입니다.
DAYNAME (날짜)
날짜의 요일 이름을 반환합니다.
mysql> SELECT DAYNAME('1998-02-05');
+---------------------------------------------------------+
| DAYNAME('1998-02-05') |
+---------------------------------------------------------+
| Thursday |
+---------------------------------------------------------+
1 row in set (0.00 sec)DAYOFMONTH (날짜)
0에서 31 사이의 날짜에 대한 날짜를 반환합니다.
mysql> SELECT DAYOFMONTH('1998-02-03');
+---------------------------------------------------------+
| DAYOFMONTH('1998-02-03') |
+---------------------------------------------------------+
| 3 |
+---------------------------------------------------------+
1 row in set (0.00 sec)DAYOFWEEK (날짜)
날짜에 대한 요일 인덱스를 반환합니다 (1 = 일요일, 2 = 월요일,., 7 = 토요일). 이러한 색인 값은 ODBC 표준에 해당합니다.
mysql> SELECT DAYOFWEEK('1998-02-03');
+---------------------------------------------------------+
|DAYOFWEEK('1998-02-03') |
+---------------------------------------------------------+
| 3 |
+---------------------------------------------------------+
1 row in set (0.00 sec)DAYOFYEAR (날짜)
1에서 366 사이의 날짜에 대한 연중 일을 반환합니다.
mysql> SELECT DAYOFYEAR('1998-02-03');
+---------------------------------------------------------+
| DAYOFYEAR('1998-02-03') |
+---------------------------------------------------------+
| 34 |
+---------------------------------------------------------+
1 row in set (0.00 sec)추출 (단위 : 날짜)
EXTRACT () 함수는 DATE_ADD () 또는 DATE_SUB ()와 동일한 종류의 단위 지정자를 사용하지만 날짜 산술을 수행하는 대신 날짜에서 부분을 추출합니다.
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)
일수 N이 주어지면 DATE 값을 반환합니다.
mysql> SELECT FROM_DAYS(729669);
+---------------------------------------------------------+
| FROM_DAYS(729669) |
+---------------------------------------------------------+
| 1997-10-07 |
+---------------------------------------------------------+
1 row in set (0.00 sec)Note− 오래된 날짜에는 조심해서 FROM_DAYS ()를 사용하십시오. 그레고리력 (1582)의 출현 이전의 값에 사용하기위한 것이 아닙니다.
FROM_UNIXTIME (unix_timestamp)
FROM_UNIXTIME (unix_timestamp, format)
의 표현을 반환합니다. unix_timestamp함수가 문자열에서 사용되는지 숫자 컨텍스트에서 사용되는지에 따라 'YYYY-MM-DD HH : MM : SS 또는 YYYYMMDDHHMMSS 형식의 값으로 인수. 값은 현재 시간대로 표시됩니다. unix_timestamp 인수는 내부 타임 스탬프 값입니다.UNIX_TIMESTAMP() 함수.
형식이 제공되면 결과는 형식 문자열에 따라 형식이 지정됩니다. 형식 문자열은 해당 항목에 나열된 것과 동일한 방식으로 사용됩니다. DATE_FORMAT() 함수.
mysql> SELECT FROM_UNIXTIME(875996580);
+---------------------------------------------------------+
| FROM_UNIXTIME(875996580) |
+---------------------------------------------------------+
| 1997-10-04 22:23:00 |
+---------------------------------------------------------+
1 row in set (0.00 sec)HOUR (시간)
시간의 시간을 반환합니다. 시간 값의 경우 반환 값의 범위는 0 ~ 23입니다. 그러나 TIME 값의 범위는 실제로 훨씬 더 크기 때문에 HOUR는 23보다 큰 값을 반환 할 수 있습니다.
mysql> SELECT HOUR('10:05:03');
+---------------------------------------------------------+
| HOUR('10:05:03') |
+---------------------------------------------------------+
| 10 |
+---------------------------------------------------------+
1 row in set (0.00 sec)LAST_DAY (날짜)
날짜 또는 날짜 시간 값을 가져 와서 해당 월의 마지막 날에 해당하는 값을 반환합니다. 인수가 유효하지 않으면 NULL을 반환합니다.
mysql> SELECT LAST_DAY('2003-02-05');
+---------------------------------------------------------+
| LAST_DAY('2003-02-05') |
+---------------------------------------------------------+
| 2003-02-28 |
+---------------------------------------------------------+
1 row in set (0.00 sec)LOCALTIME 및 LOCALTIME ()
LOCALTIME 및 LOCALTIME ()은 NOW ()의 동의어입니다.
LOCALTIMESTAMP 및 LOCALTIMESTAMP ()
LOCALTIMESTAMP 및 LOCALTIMESTAMP ()는 NOW ()의 동의어입니다.
MAKEDATE (연도, 일)
주어진 연도와 날짜 값으로 날짜를 반환합니다. dayofyear 값은 0보다 커야합니다. 그렇지 않으면 결과가 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 (시, 분, 초)
시간, 분 및 초 인수에서 계산 된 시간 값을 반환합니다.
mysql> SELECT MAKETIME(12,15,30);
+---------------------------------------------------------+
| MAKETIME(12,15,30) |
+---------------------------------------------------------+
| '12:15:30' |
+---------------------------------------------------------+
1 row in set (0.00 sec)MICROSECOND (expr)
시간 또는 날짜 시간 표현식 (expr)에서 마이크로 초를 0에서 999999 범위의 숫자로 반환합니다.
mysql> SELECT MICROSECOND('12:00:00.123456');
+---------------------------------------------------------+
| MICROSECOND('12:00:00.123456') |
+---------------------------------------------------------+
| 123456 |
+---------------------------------------------------------+
1 row in set (0.00 sec)MINUTE (시간)
시간의 분을 0에서 59 사이로 반환합니다.
mysql> SELECT MINUTE('98-02-03 10:05:03');
+---------------------------------------------------------+
| MINUTE('98-02-03 10:05:03') |
+---------------------------------------------------------+
| 5 |
+---------------------------------------------------------+
1 row in set (0.00 sec)MONTH (날짜)
날짜의 월을 0에서 12까지 반환합니다.
mysql> SELECT MONTH('1998-02-03')
+---------------------------------------------------------+
| MONTH('1998-02-03') |
+---------------------------------------------------------+
| 2 |
+---------------------------------------------------------+
1 row in set (0.00 sec)MONTHNAME (날짜)
날짜에 대한 월의 전체 이름을 반환합니다.
mysql> SELECT MONTHNAME('1998-02-05');
+---------------------------------------------------------+
| MONTHNAME('1998-02-05') |
+---------------------------------------------------------+
| February |
+---------------------------------------------------------+
1 row in set (0.00 sec)지금()
함수가 문자열 또는 숫자 컨텍스트에서 사용되는지 여부에 따라 현재 날짜 및 시간을 'YYYY-MM-DD HH : MM : SS'또는 YYYYMMDDHHMMSS 형식의 값으로 반환합니다. 이 값은 현재 시간대로 표시됩니다.
mysql> SELECT NOW();
+---------------------------------------------------------+
| NOW() |
+---------------------------------------------------------+
| 1997-12-15 23:50:26 |
+---------------------------------------------------------+
1 row in set (0.00 sec)PERIOD_ADD (P, N)
기간 P에 N 개월을 추가합니다 (YYMM 또는 YYYYMM 형식). YYYYMM 형식의 값을 반환합니다. 기간 인수 P는 날짜 값이 아닙니다.
mysql> SELECT PERIOD_ADD(9801,2);
+---------------------------------------------------------+
| PERIOD_ADD(9801,2) |
+---------------------------------------------------------+
| 199803 |
+---------------------------------------------------------+
1 row in set (0.00 sec)PERIOD_DIFF (P1, P2)
기간 P1과 P2 사이의 개월 수를 반환합니다. 이러한 기간 P1 및 P2는 YYMM 또는 YYYYMM 형식이어야합니다. 기간 인수 P1 및 P2는 날짜 값이 아닙니다.
mysql> SELECT PERIOD_DIFF(9802,199703);
+---------------------------------------------------------+
| PERIOD_DIFF(9802,199703) |
+---------------------------------------------------------+
| 11 |
+---------------------------------------------------------+
1 row in set (0.00 sec)QUARTER (날짜)
1에서 4까지의 범위에서 날짜에 대한 분기를 반환합니다.
mysql> SELECT QUARTER('98-04-01');
+---------------------------------------------------------+
| QUARTER('98-04-01') |
+---------------------------------------------------------+
| 2 |
+---------------------------------------------------------+
1 row in set (0.00 sec)두번째)
시간의 초를 0에서 59 사이의 범위로 반환합니다.
mysql> SELECT SECOND('10:05:03');
+---------------------------------------------------------+
| SECOND('10:05:03') |
+---------------------------------------------------------+
| 3 |
+---------------------------------------------------------+
1 row in set (0.00 sec)SEC_TO_TIME (초)
함수가 문자열 또는 숫자 컨텍스트에서 사용되는지 여부에 따라 'HH : MM : SS'또는 HHMMSS 형식의 값으로 시간, 분 및 초로 변환 된 초 인수를 리턴합니다.
mysql> SELECT SEC_TO_TIME(2378);
+---------------------------------------------------------+
| SEC_TO_TIME(2378) |
+---------------------------------------------------------+
| 00:39:38 |
+---------------------------------------------------------+
1 row in set (0.00 sec)STR_TO_DATE (str, 형식)
이것은 DATE_FORMAT () 함수의 역입니다. str 문자열과 형식 문자열 형식을 취합니다. STR_TO_DATE () 함수는 형식 문자열에 날짜 및 시간 부분이 모두 포함 된 경우 DATETIME 값을 반환합니다. 그렇지 않으면 문자열에 날짜 또는 시간 부분 만 포함 된 경우 DATE 또는 TIME 값을 반환합니다.
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 (date, INTERVAL expr unit) 및 SUBDATE (expr, days)
두 번째 인수의 INTERVAL 형식으로 호출되면 SUBDATE ()는 DATE_SUB ()의 동의어입니다. INTERVAL 단위 인수에 대한 정보는 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 (expr1, expr2)
SUBTIME () 함수는 expr1을 반환합니다. expr1과 동일한 형식의 값으로 표현되는 expr2. expr1 값은 시간 또는 datetime 표현식이고 expr2 값은 시간 표현식입니다.
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 ()
함수가 문자열에서 사용되는지 숫자 컨텍스트에서 사용되는지에 따라 현재 날짜 및 시간을 'YYYY-MM-DD HH : MM : SS'또는 YYYYMMDDHHMMSS 형식의 값으로 반환합니다.
mysql> SELECT SYSDATE();
+---------------------------------------------------------+
| SYSDATE() |
+---------------------------------------------------------+
| 2006-04-12 13:47:44 |
+---------------------------------------------------------+
1 row in set (0.00 sec)시간 (expr)
시간 또는 datetime 식의 시간 부분을 추출합니다. expr 문자열로 반환합니다.
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 (expr1, expr2)
TIMEDIFF () 함수는 expr1을 반환합니다. expr2는 시간 값으로 표현됩니다. 이러한 expr1 및 expr2 값은 시간 또는 날짜 및 시간 표현식이지만 둘 다 동일한 유형이어야합니다.
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 (expr), TIMESTAMP (expr1, expr2)
단일 인수를 사용하는이 함수는 날짜 또는 날짜 시간 표현식 expr을 날짜 시간 값으로 반환합니다. 두 개의 인수를 사용하여 날짜 또는 날짜 / 시간 표현식에 시간 표현식 expr2를 추가합니다.expr1 결과를 datetime 값으로 반환합니다.
mysql> SELECT TIMESTAMP('2003-12-31');
+---------------------------------------------------------+
| TIMESTAMP('2003-12-31') |
+---------------------------------------------------------+
| 2003-12-31 00:00:00 |
+---------------------------------------------------------+
1 row in set (0.00 sec)TIMESTAMPADD (단위, 간격, datetime_expr)
이 함수는 날짜 또는 날짜 시간 표현식에 정수 표현식 간격을 추가합니다. datetime_expr. 간격의 단위는 다음 값 중 하나 여야하는 단위 인수로 지정됩니다.
- FRAC_SECOND
- SECOND, MINUTE
- HOUR, DAY
- WEEK
- MONTH
- QUARTER 또는
- YEAR
단위 값은 표시된대로 키워드 중 하나를 사용하거나 접두어 SQL_TSI_를 사용하여 지정할 수 있습니다.
예를 들어, DAY와 SQL_TSI_DAY는 모두 합법적입니다.
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 (unit, datetime_expr1, datetime_expr2)
날짜 또는 날짜 시간 표현식 datetime_expr1과 datetime_expr2 간의 정수 차이를 반환합니다. 결과의 단위는 단위 인수로 제공됩니다. 단위의 유효한 값은 TIMESTAMPADD () 함수의 설명에 나열된 값과 동일합니다.
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 (시간, 형식)
이 함수는 DATE_FORMAT () 함수처럼 사용되지만 형식 문자열에는 시간, 분 및 초에 대한 형식 지정자 만 포함될 수 있습니다.
시간 값에 23보다 큰 시간 부분이 포함 된 경우 %H 및 %k 시간 형식 지정자는 0에서 23까지의 일반적인 범위보다 큰 값을 생성합니다. 다른 시간 형식 지정자는 모듈로 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 (시간)
초로 변환 된 시간 인수를 반환합니다.
mysql> SELECT TIME_TO_SEC('22:23:00');
+---------------------------------------------------------+
| TIME_TO_SEC('22:23:00') |
+---------------------------------------------------------+
| 80580 |
+---------------------------------------------------------+
1 row in set (0.00 sec)오늘 날짜)
날짜가 주어지면 일 수 (0 년 이후의 일 수)를 반환합니다.
mysql> SELECT TO_DAYS(950501);
+---------------------------------------------------------+
| TO_DAYS(950501) |
+---------------------------------------------------------+
| 728779 |
+---------------------------------------------------------+
1 row in set (0.00 sec)UNIX_TIMESTAMP (), UNIX_TIMESTAMP (날짜)
인수없이 호출되면이 함수는 Unix 타임 스탬프 ( '1970-01-01 00:00:00'UTC 이후 초)를 부호없는 정수로 반환합니다. UNIX_TIMESTAMP ()가 date 인수와 함께 호출되면 '1970-01-01 00:00:00'UTC 이후 인수 값을 초로 반환합니다. date는 DATE 문자열, DATETIME 문자열, TIMESTAMP 또는 YYMMDD 또는 YYYYMMDD 형식의 숫자 일 수 있습니다.
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 ()
함수가 문자열 또는 숫자 컨텍스트에서 사용되는지 여부에 따라 현재 UTC 날짜를 'YYYY-MM-DD'또는 YYYYMMDD 형식의 값으로 반환합니다.
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 ()
함수가 문자열 또는 숫자 컨텍스트에서 사용되는지 여부에 따라 현재 UTC 시간을 'HH : MM : SS'또는 HHMMSS 형식의 값으로 반환합니다.
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 ()
함수가 문자열 또는 숫자 컨텍스트에서 사용되는지 여부에 따라 현재 UTC 날짜 및 시간을 'YYYY-MM-DD HH : MM : SS'또는 YYYYMMDDHHMMSS 형식의 값으로 반환합니다.
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)WEEK (날짜 [, 모드])
이 함수는 날짜의 주 번호를 반환합니다. WEEK ()의 두 인수 형식을 사용하면 주가 일요일 또는 월요일에 시작하는지 여부와 반환 값이 0에서 53 사이 또는 1에서 53 사이 여야하는지 여부를 지정할 수 있습니다. mode 인수가 생략되면, default_week_format 시스템 변수의 값이 사용됩니다.
| 방법 | 요일 | 범위 | 1 주차는 첫 번째 주입니다. |
|---|---|---|---|
| 0 | 일요일 | 0-53 | 올해는 일요일 |
| 1 | 월요일 | 0-53 | 올해 3 일 이상 |
| 2 | 일요일 | 1-53 | 올해는 일요일 |
| 삼 | 월요일 | 1-53 | 올해 3 일 이상 |
| 4 | 일요일 | 0-53 | 올해 3 일 이상 |
| 5 | 월요일 | 0-53 | 올해는 월요일 |
| 6 | 일요일 | 1-53 | 올해 3 일 이상 |
| 7 | 월요일 | 1-53 | 올해는 월요일 |
mysql> SELECT WEEK('1998-02-20');
+---------------------------------------------------------+
| WEEK('1998-02-20') |
+---------------------------------------------------------+
| 7 |
+---------------------------------------------------------+
1 row in set (0.00 sec)WEEKDAY (날짜)
날짜에 대한 요일 인덱스를 반환합니다 (0 = 월요일, 1 = 화요일,. 6 = 일요일).
mysql> SELECT WEEKDAY('1998-02-03 22:23:00');
+---------------------------------------------------------+
| WEEKDAY('1998-02-03 22:23:00') |
+---------------------------------------------------------+
| 1 |
+---------------------------------------------------------+
1 row in set (0.00 sec)WEEKOFYEAR (날짜)
날짜의 달력 주를 1에서 53 사이의 숫자로 반환합니다. WEEKOFYEAR ()는 WEEK (date, 3)에 해당하는 호환성 함수입니다.
mysql> SELECT WEEKOFYEAR('1998-02-20');
+---------------------------------------------------------+
| WEEKOFYEAR('1998-02-20') |
+---------------------------------------------------------+
| 8 |
+---------------------------------------------------------+
1 row in set (0.00 sec)YEAR (날짜)
날짜의 연도를 1000에서 9999 사이의 범위로 반환하거나 .zero의 경우 0을 반환합니다. 데이트.
mysql> SELECT YEAR('98-02-03');
+---------------------------------------------------------+
| YEAR('98-02-03') |
+---------------------------------------------------------+
| 1998 |
+---------------------------------------------------------+
1 row in set (0.00 sec)YEARWEEK (날짜), YEARWEEK (날짜, 모드)
날짜의 연도와 주를 반환합니다. mode 인수는 WEEK () 함수에 대한 mode 인수와 똑같이 작동합니다. 결과의 연도는 해당 연도의 첫 번째 및 마지막 주에 대한 date 인수의 연도와 다를 수 있습니다.
mysql> SELECT YEARWEEK('1987-01-01');
+---------------------------------------------------------+
| YEAR('98-02-03')YEARWEEK('1987-01-01') |
+---------------------------------------------------------+
| 198653 |
+---------------------------------------------------------+
1 row in set (0.00 sec)Note − WEEK () 함수가 선택적 인수 0 또는 1에 대해 (0)을 반환하는 것과 다르며 WEEK ()는 주어진 연도의 컨텍스트에서 주를 반환합니다.
SQL-임시 테이블
임시 테이블이란 무엇입니까?
임시 테이블을 지원하는 RDBMS가 있습니다. 임시 테이블은 다음을 수행 할 수있는 훌륭한 기능입니다.store and process intermediate results 일반적인 SQL Server 테이블에서 사용할 수있는 것과 동일한 선택, 업데이트 및 조인 기능을 사용합니다.
임시 테이블은 경우에 따라 임시 데이터를 유지하는 데 매우 유용 할 수 있습니다. 임시 테이블에 대해 알아야 할 가장 중요한 점은 현재 클라이언트 세션이 종료 될 때 삭제된다는 것입니다.
임시 테이블은 MySQL 버전 3.23 이상에서 사용할 수 있습니다. 3.23 이전 버전의 MySQL을 사용하는 경우 임시 테이블을 사용할 수 없지만 사용할 수 있습니다.heap tables.
앞서 언급했듯이 임시 테이블은 세션이 살아있는 동안 만 지속됩니다. PHP 스크립트에서 코드를 실행하면 스크립트 실행이 완료되면 임시 테이블이 자동으로 삭제됩니다. MySQL 클라이언트 프로그램을 통해 MySQL 데이터베이스 서버에 연결 한 경우 클라이언트를 닫거나 테이블을 수동으로 삭제할 때까지 임시 테이블이 존재합니다.
예
다음은 임시 테이블의 사용법을 보여주는 예입니다.
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)SHOW TABLES 명령을 실행하면 임시 테이블이 목록에 나열되지 않습니다. 이제 MySQL 세션에서 로그 아웃 한 다음 SELECT 명령을 실행하면 데이터베이스에서 사용 가능한 데이터를 찾을 수 없습니다. 임시 테이블조차도 존재하지 않습니다.
임시 테이블 삭제
기본적으로 모든 임시 테이블은 데이터베이스 연결이 종료 될 때 MySQL에 의해 삭제됩니다. 그래도 중간에 삭제하려면 다음을 발행하여 삭제할 수 있습니다.DROP TABLE 명령.
다음은 임시 테이블 삭제에 대한 예입니다.
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 existSQL-테이블 복제
테이블의 정확한 사본이 필요하고 CREATE TABLE ... 또는 SELECT ... 명령이 동일한 색인, 기본값 등을 포함해야하기 때문에 사용자의 목적에 맞지 않는 상황이있을 수 있습니다.
MySQL RDBMS를 사용하는 경우 아래 단계에 따라이 상황을 처리 할 수 있습니다.
SHOW CREATE TABLE 명령을 사용하여 소스 테이블의 구조, 인덱스 및 모두를 지정하는 CREATE TABLE 문을 가져옵니다.
문을 수정하여 테이블 이름을 복제 테이블의 이름으로 변경하고 문을 실행합니다. 이렇게하면 정확한 클론 테이블이 생성됩니다.
선택적으로 테이블 내용도 복사해야하는 경우 INSERT INTO 또는 SELECT 문도 실행하십시오.
예
다음 예제를 사용하여 복제 테이블을 만듭니다. TUTORIALS_TBL 그 구조는 다음과 같습니다-
Step 1 − 테이블에 대한 완전한 구조를 얻습니다.
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 −이 테이블의 이름을 변경하고 다른 테이블을 생성하십시오.
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− 2 단계를 실행 한 후 데이터베이스에서 테이블을 복제합니다. 이전 테이블에서 데이터를 복사하려면 INSERT INTO ... SELECT 문을 사용하면됩니다.
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마지막으로, 원하는대로 정확한 복제 테이블을 갖게됩니다.
SQL-하위 쿼리
하위 쿼리, 내부 쿼리 또는 중첩 쿼리는 다른 SQL 쿼리 내의 쿼리이며 WHERE 절에 포함됩니다.
하위 쿼리는 검색 할 데이터를 추가로 제한하는 조건으로 기본 쿼리에서 사용될 데이터를 반환하는 데 사용됩니다.
하위 쿼리는 =, <,>,> =, <=, IN, BETWEEN 등과 같은 연산자와 함께 SELECT, INSERT, UPDATE 및 DELETE 문과 함께 사용할 수 있습니다.
하위 쿼리가 따라야하는 몇 가지 규칙이 있습니다.
하위 쿼리는 괄호로 묶어야합니다.
하위 쿼리가 선택한 열을 비교하기위한 기본 쿼리에 여러 열이있는 경우가 아니면 하위 쿼리는 SELECT 절에 하나의 열만 가질 수 있습니다.
기본 쿼리는 ORDER BY를 사용할 수 있지만 ORDER BY 명령은 하위 쿼리에서 사용할 수 없습니다. GROUP BY 명령을 사용하여 하위 쿼리의 ORDER BY와 동일한 기능을 수행 할 수 있습니다.
둘 이상의 행을 반환하는 하위 쿼리는 IN 연산자와 같은 여러 값 연산자와 함께 만 사용할 수 있습니다.
SELECT 목록에는 BLOB, ARRAY, CLOB 또는 NCLOB로 평가되는 값에 대한 참조가 포함될 수 없습니다.
하위 쿼리는 집합 함수에 즉시 포함될 수 없습니다.
BETWEEN 연산자는 하위 쿼리와 함께 사용할 수 없습니다. 그러나 BETWEEN 연산자는 하위 쿼리 내에서 사용할 수 있습니다.
SELECT 문을 사용하는 하위 쿼리
하위 쿼리는 SELECT 문과 함께 가장 자주 사용됩니다. 기본 구문은 다음과 같습니다.
SELECT column_name [, column_name ]
FROM table1 [, table2 ]
WHERE column_name OPERATOR
(SELECT column_name [, column_name ]
FROM table1 [, table2 ]
[WHERE])예
다음 레코드가있는 CUSTOMERS 테이블을 고려하십시오.
+----+----------+-----+-----------+----------+
| 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 |
+----+----------+-----+-----------+----------+이제 SELECT 문을 사용하여 다음 하위 쿼리를 확인하겠습니다.
SQL> SELECT *
FROM CUSTOMERS
WHERE ID IN (SELECT ID
FROM CUSTOMERS
WHERE SALARY > 4500) ;그러면 다음과 같은 결과가 생성됩니다.
+----+----------+-----+---------+----------+
| ID | NAME | AGE | ADDRESS | SALARY |
+----+----------+-----+---------+----------+
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+----------+-----+---------+----------+INSERT 문이있는 하위 쿼리
INSERT 문과 함께 하위 쿼리를 사용할 수도 있습니다. INSERT 문은 하위 쿼리에서 반환 된 데이터를 사용하여 다른 테이블에 삽입합니다. 하위 쿼리에서 선택한 데이터는 문자, 날짜 또는 숫자 함수로 수정할 수 있습니다.
기본 구문은 다음과 같습니다.
INSERT INTO table_name [ (column1 [, column2 ]) ]
SELECT [ *|column1 [, column2 ]
FROM table1 [, table2 ]
[ WHERE VALUE OPERATOR ]예
CUSTOMERS 테이블과 유사한 구조를 가진 테이블 CUSTOMERS_BKP를 고려하십시오. 이제 전체 CUSTOMERS 테이블을 CUSTOMERS_BKP 테이블에 복사하려면 다음 구문을 사용할 수 있습니다.
SQL> INSERT INTO CUSTOMERS_BKP
SELECT * FROM CUSTOMERS
WHERE ID IN (SELECT ID
FROM CUSTOMERS) ;UPDATE 문이있는 하위 쿼리
하위 쿼리는 UPDATE 문과 함께 사용할 수 있습니다. UPDATE 문과 함께 하위 쿼리를 사용할 때 테이블의 단일 또는 여러 열을 업데이트 할 수 있습니다.
기본 구문은 다음과 같습니다.
UPDATE table
SET column_name = new_value
[ WHERE OPERATOR [ VALUE ]
(SELECT COLUMN_NAME
FROM TABLE_NAME)
[ WHERE) ]예
CUSTOMERS 테이블의 백업 인 CUSTOMERS_BKP 테이블을 사용할 수 있다고 가정합니다. 다음 예는 AGE가 27 이상인 모든 고객에 대해 CUSTOMERS 테이블에서 SALARY를 0.25 배 업데이트합니다.
SQL> UPDATE CUSTOMERS
SET SALARY = SALARY * 0.25
WHERE AGE IN (SELECT AGE FROM CUSTOMERS_BKP
WHERE AGE >= 27 );이것은 두 행에 영향을 미치고 마지막으로 CUSTOMERS 테이블에 다음 레코드가 있습니다.
+----+----------+-----+-----------+----------+
| 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 |
+----+----------+-----+-----------+----------+DELETE 문이있는 하위 쿼리
하위 쿼리는 위에서 언급 한 다른 문과 마찬가지로 DELETE 문과 함께 사용할 수 있습니다.
기본 구문은 다음과 같습니다.
DELETE FROM TABLE_NAME
[ WHERE OPERATOR [ VALUE ]
(SELECT COLUMN_NAME
FROM TABLE_NAME)
[ WHERE) ]예
CUSTOMERS 테이블의 백업 인 CUSTOMERS_BKP 테이블을 사용할 수 있다고 가정합니다. 다음 예에서는 AGE가 27 이상인 모든 고객에 대해 CUSTOMERS 테이블에서 레코드를 삭제합니다.
SQL> DELETE FROM CUSTOMERS
WHERE AGE IN (SELECT AGE FROM CUSTOMERS_BKP
WHERE AGE >= 27 );이것은 두 행에 영향을 미치고 마지막으로 CUSTOMERS 테이블에는 다음 레코드가 있습니다.
+----+----------+-----+---------+----------+
| 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-시퀀스 사용
시퀀스는 요청시 순서대로 생성되는 정수 1, 2, 3, ...의 집합입니다. 많은 애플리케이션이 고유 한 값을 포함하기 위해 테이블의 각 행을 요구하고 시퀀스를 생성하는 쉬운 방법을 제공하기 때문에 시퀀스는 데이터베이스에서 자주 사용됩니다.
이 장에서는 MySQL에서 시퀀스를 사용하는 방법에 대해 설명합니다.
AUTO_INCREMENT 컬럼 사용
MySQL에서 시퀀스를 사용하는 가장 간단한 방법은 열을 AUTO_INCREMENT로 정의하고 나머지는 MySQL에 맡기는 것입니다.
예
다음 예제를 시도해보십시오. 이렇게하면 테이블이 생성되고 그 후에 MySQL에 의해 자동으로 증가하므로 레코드 ID를 제공 할 필요가없는이 테이블에 몇 개의 행을 삽입합니다.
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)AUTO_INCREMENT 값 얻기
LAST_INSERT_ID ()는 SQL 함수이므로 SQL 문을 실행하는 방법을 이해하는 모든 클라이언트 내에서 사용할 수 있습니다. 그렇지 않으면 PERL 및 PHP 스크립트는 마지막 레코드의 자동 증가 값을 검색하는 독점 기능을 제공합니다.
PERL 예
사용 mysql_insertid질의에 의해 생성 된 AUTO_INCREMENT 값을 얻기위한 속성. 이 속성은 쿼리를 실행하는 방법에 따라 데이터베이스 핸들 또는 명령문 핸들을 통해 액세스됩니다. 다음 예제는 데이터베이스 핸들을 통해이를 참조합니다.
$dbh->do ("INSERT INTO INSECT (name,date,origin) VALUES('moth','2001-09-14','windowsill')"); my $seq = $dbh->{mysql_insertid};PHP 예
AUTO_INCREMENT 값을 생성하는 쿼리를 실행 한 후 다음을 호출하여 값을 검색합니다. mysql_insert_id( ) 함수.
mysql_query ("INSERT INTO INSECT (name,date,origin)
VALUES('moth','2001-09-14','windowsill')", $conn_id);
$seq = mysql_insert_id ($conn_id);기존 시퀀스 번호 다시 매기기
테이블에서 많은 레코드를 삭제하고 모든 레코드의 순서를 다시 지정하려는 경우가있을 수 있습니다. 이것은 간단한 트릭을 사용하여 수행 할 수 있지만이 작업을 수행하는 데 매우주의해야하며 테이블이 다른 테이블과 조인되는지 여부를 확인해야합니다.
AUTO_INCREMENT 열을 다시 시퀀싱하는 것이 불가피하다고 판단되는 경우이를 수행하는 방법은 테이블에서 열을 삭제 한 다음 다시 추가하는 것입니다.
다음 예제는이 기술을 사용하여 곤충 테이블에서 ID 값의 번호를 다시 매기는 방법을 보여줍니다.
mysql> ALTER TABLE INSECT DROP id;
mysql> ALTER TABLE insect
-> ADD id INT UNSIGNED NOT NULL AUTO_INCREMENT FIRST,
-> ADD PRIMARY KEY (id);특정 값에서 시퀀스 시작
기본적으로 MySQL은 1부터 시퀀스를 시작하지만 테이블 생성시 다른 숫자도 지정할 수 있습니다.
다음 코드 블록에는 MySQL이 100부터 시퀀스를 시작하는 예제가 있습니다.
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
);또는 테이블을 만든 다음 ALTER TABLE을 사용하여 초기 시퀀스 값을 설정할 수 있습니다.
mysql> ALTER TABLE t AUTO_INCREMENT = 100;SQL-중복 처리
테이블에 중복 레코드가 여러 개있는 상황이있을 수 있습니다. 이러한 레코드를 가져 오는 동안 중복 레코드를 가져 오는 대신 고유 한 레코드 만 가져 오는 것이 더 합리적입니다.
SQL DISTINCT 이미 논의한 키워드는 SELECT 문과 함께 사용되어 모든 중복 레코드를 제거하고 고유 한 레코드 만 가져옵니다.
통사론
중복 레코드를 제거하기위한 DISTINCT 키워드의 기본 구문은 다음과 같습니다.
SELECT DISTINCT column1, column2,.....columnN
FROM table_name
WHERE [condition]예
다음 레코드가있는 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 |
+----+----------+-----+-----------+----------+먼저 다음 SELECT 쿼리가 중복 급여 레코드를 반환하는 방법을 살펴 보겠습니다.
SQL> SELECT SALARY FROM CUSTOMERS
ORDER BY SALARY;이렇게하면 원래 테이블에서 중복 된 레코드 인 2000 년 급여가 두 배가되는 다음 결과가 생성됩니다.
+----------+
| SALARY |
+----------+
| 1500.00 |
| 2000.00 |
| 2000.00 |
| 4500.00 |
| 6500.00 |
| 8500.00 |
| 10000.00 |
+----------+이제 위의 SELECT 쿼리에 DISTINCT 키워드를 사용하여 결과를 확인하겠습니다.
SQL> SELECT DISTINCT SALARY FROM CUSTOMERS
ORDER BY SALARY;중복 항목이없는 경우 다음과 같은 결과가 생성됩니다.
+----------+
| SALARY |
+----------+
| 1500.00 |
| 2000.00 |
| 4500.00 |
| 6500.00 |
| 8500.00 |
| 10000.00 |
+----------+SQL-주입
웹 페이지를 통해 사용자 입력을 가져 와서 SQL 데이터베이스에 삽입하면 다음과 같은 보안 문제로 인해 자신을 활짝 열어 놓을 가능성이 있습니다. SQL Injection. 이 장에서는 이러한 일이 발생하지 않도록 방지하고 PERL 스크립트와 같은 서버 측 스크립트에서 스크립트 및 SQL 문을 보호하는 방법을 알려줍니다.
주입은 일반적으로 사용자에게 이름과 같은 입력을 요청할 때 발생하며 이름 대신 데이터베이스에서 무의식적으로 실행할 SQL 문을 제공합니다. 사용자가 제공 한 데이터를 신뢰하지 말고 유효성 검사 후에 만이 데이터를 처리하십시오. 일반적으로 이것은Pattern Matching.
아래 예에서 name 영숫자 문자와 밑줄 및 8-20 자 사이의 길이로 제한됩니다 (필요에 따라 이러한 규칙을 수정하십시오).
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";
}문제를 설명하기 위해이 발췌를 고려하십시오.
// supposed input
$name = "Qadir'; DELETE FROM CUSTOMERS;";
mysql_query("SELECT * FROM CUSTOMSRS WHERE name='{$name}'");함수 호출은 이름 열이 사용자가 지정한 이름과 일치하는 CUSTOMERS 테이블에서 레코드를 검색해야합니다. 정상적인 상황에서$name영숫자 문자와 ilia 문자열과 같은 공백 만 포함합니다. 그러나 여기서 $ name에 완전히 새로운 쿼리를 추가하면 데이터베이스 호출이 재앙이됩니다. 삽입 된 DELETE 쿼리는 CUSTOMERS 테이블에서 모든 레코드를 제거합니다.
다행히도 MySQL을 사용하는 경우 mysql_query()함수는 단일 함수 호출에서 쿼리 스택 또는 여러 SQL 쿼리 실행을 허용하지 않습니다. 쿼리를 스택하려고하면 호출이 실패합니다.
그러나 다음과 같은 다른 PHP 데이터베이스 확장은 SQLite 과 PostgreSQL 스택 쿼리를 즐겁게 수행하고 하나의 문자열로 제공된 모든 쿼리를 실행하면 심각한 보안 문제가 발생합니다.
SQL 주입 방지
PERL 및 PHP와 같은 스크립팅 언어에서 모든 이스케이프 문자를 현명하게 처리 할 수 있습니다. PHP 용 MySQL 확장은 다음 기능을 제공합니다.mysql_real_escape_string() MySQL에 특수한 입력 문자를 이스케이프합니다.
if (get_magic_quotes_gpc()) {
$name = stripslashes($name); } $name = mysql_real_escape_string($name); mysql_query("SELECT * FROM CUSTOMERS WHERE name='{$name}'");LIKE Quandary
LIKE 문제를 해결하려면 사용자 지정 이스케이프 메커니즘이 사용자 제공 '%'및 '_'문자를 리터럴로 변환해야합니다. 사용하다addcslashes(), 이스케이프 할 문자 범위를 지정할 수있는 함수입니다.
$sub = addcslashes(mysql_real_escape_string("%str"), "%_"); // $sub == \%str\_
mysql_query("SELECT * FROM messages
WHERE subject LIKE '{$sub}%'");SQL-데이터베이스 튜닝
데이터베이스 전문가 또는 전문 데이터베이스 관리자가 되려면 시간이 걸립니다. 이 모든 것은 다양한 데이터베이스 설계와 훌륭한 교육에 대한 많은 경험과 함께 제공됩니다.
그러나 다음 목록은 초보자가 좋은 데이터베이스 성능을 갖는 데 도움이 될 수 있습니다.
RDBMS 개념 장에서이 튜토리얼에 설명 된 3BNF 데이터베이스 디자인을 사용하십시오.
숫자와 문자가 다르게 비교되고 성능이 저하되므로 숫자를 문자로 변환하지 마십시오.
SELECT 문을 사용하는 동안 필요한 정보 만 가져오고 SELECT 쿼리에 *를 사용하지 마십시오. 시스템이 불필요하게로드 될 수 있기 때문입니다.
검색 작업이 빈번한 모든 테이블에서 신중하게 인덱스를 생성하십시오. 검색 작업 수가 적고 삽입 및 업데이트 작업 수가 많은 테이블에 대한 색인을 피하십시오.
전체 테이블 스캔은 WHERE 절의 열에 연관된 색인이 없을 때 발생합니다. SQL 문의 WHERE 절에서 조건으로 사용되는 열에 인덱스를 생성하여 전체 테이블 스캔을 피할 수 있습니다.
실수와 날짜 / 시간 값이있는 등호 연산자에주의하십시오. 둘 다 눈에 분명하지 않지만 정확한 일치를 불가능하게 만드는 작은 차이가있을 수 있으므로 쿼리가 행을 반환하지 못합니다.
패턴 일치를 신중하게 사용하십시오. LIKE COL %는 유효한 WHERE 조건으로, 반환 된 집합을 문자열 COL로 시작하는 데이터가있는 레코드로만 줄입니다. 그러나 COL % Y는 % Y를 효과적으로 평가할 수 없기 때문에 반환 된 결과 집합을 더 이상 줄이지 않습니다. 평가를 수행하려는 노력이 너무 커서 고려할 수 없습니다. 이 경우 COL %가 사용되지만 % Y는 버려집니다. 같은 이유로 선행 와일드 카드 % COL은 전체 필터가 사용되는 것을 효과적으로 방지합니다.
쿼리 (및 하위 쿼리)의 구조 인 SQL 구문을 검사하는 SQL 쿼리를 미세 조정하여 빠른 데이터 조작을 지원하도록 테이블을 설계하고 최적의 방식으로 쿼리를 작성하여 DBMS가 데이터를 효율적으로 조작 할 수 있도록합니다. .
정기적으로 실행되는 쿼리의 경우 프로 시저를 사용해보십시오. 프로시 저는 잠재적으로 큰 SQL 문 그룹입니다. 프로시 저는 데이터베이스 엔진에 의해 컴파일 된 다음 실행됩니다. SQL 문과 달리 데이터베이스 엔진은 실행되기 전에 프로 시저를 최적화 할 필요가 없습니다.
가능하면 쿼리에서 논리 연산자 OR을 사용하지 마십시오. 또는 상당한 크기의 테이블에 대한 거의 모든 쿼리를 필연적으로 느리게 만듭니다.
인덱스를 삭제하여 대량 데이터로드를 최적화 할 수 있습니다. 수천 개의 행이있는 히스토리 테이블을 상상해보십시오. 해당 히스토리 테이블에는 하나 이상의 인덱스가있을 수도 있습니다. 인덱스를 생각할 때 일반적으로 더 빠른 테이블 액세스를 생각하지만 일괄로드의 경우 인덱스를 삭제하면 이점을 얻을 수 있습니다.
일괄 트랜잭션을 수행 할 때 모든 레코드 생성 후 생성하는 대신 상당한 수의 레코드 생성 후 COMMIT를 수행합니다.
주별 루틴을 개발하는 것을 의미하더라도 정기적으로 데이터베이스 조각 모음을 계획하십시오.
내장 튜닝 도구
Oracle에는 SQL 문 성능을 관리하기위한 많은 도구가 있지만 그 중에서 두 가지가 매우 유명합니다. 이 두 도구는-
Explain plan − 도구는 SQL 문이 실행될 때 사용할 액세스 경로를 식별합니다.
tkprof − 각 SQL 문 처리 단계에서 경과 된 시간별로 성능을 측정합니다.
Oracle에서 쿼리의 경과 시간을 간단히 측정하려는 경우 SQL * Plus 명령 SET TIMING ON을 사용할 수 있습니다.
위에서 언급 한 도구 및 데이터베이스 조각 모음에 대한 자세한 내용은 RDBMS 설명서를 확인하십시오.