SQLite-퀵 가이드

이 장은 SQLite가 무엇인지, SQL과 어떻게 다른지, 왜 필요한지, 그리고 애플리케이션 데이터베이스를 처리하는 방법을 이해하는 데 도움이됩니다.

SQLite는 자체 포함, 서버리스, 제로 구성, 트랜잭션 SQL 데이터베이스 엔진을 구현하는 소프트웨어 라이브러리입니다. SQLite는 가장 빠르게 성장하는 데이터베이스 엔진 중 하나이지만, 그 크기와는 상관없는 인기도 증가입니다. SQLite의 소스 코드는 공개 도메인에 있습니다.

SQLite 란 무엇입니까?

SQLite는 자체 포함, 서버리스, 제로 구성, 트랜잭션 SQL 데이터베이스 엔진을 구현하는 프로세스 내 라이브러리입니다. 제로 구성되는 데이터베이스이므로 다른 데이터베이스와 마찬가지로 시스템에서 구성 할 필요가 없습니다.

SQLite 엔진은 다른 데이터베이스와 같은 독립 실행 형 프로세스가 아니므로 애플리케이션과의 요구 사항에 따라 정적으로 또는 동적으로 연결할 수 있습니다. SQLite는 스토리지 파일에 직접 액세스합니다.

왜 SQLite인가?

  • SQLite는 별도의 서버 프로세스 나 시스템이 필요하지 않습니다 (서버리스).

  • SQLite는 구성이 필요하지 않으므로 설정이나 관리가 필요하지 않습니다.

  • 완전한 SQLite 데이터베이스는 단일 크로스 플랫폼 디스크 파일에 저장됩니다.

  • SQLite는 매우 작고 가벼우 며 완전히 구성된 400KiB 미만이거나 옵션 기능이 생략 된 250KiB 미만입니다.

  • SQLite는 독립적이므로 외부 종속성이 없습니다.

  • SQLite 트랜잭션은 ACID를 완전히 준수하므로 여러 프로세스 또는 스레드에서 안전하게 액세스 할 수 있습니다.

  • SQLite는 SQL92 (SQL2) 표준에있는 대부분의 쿼리 언어 기능을 지원합니다.

  • SQLite는 ANSI-C로 작성되었으며 간단하고 사용하기 쉬운 API를 제공합니다.

  • SQLite는 UNIX (Linux, Mac OS-X, Android, iOS) 및 Windows (Win32, WinCE, WinRT)에서 사용할 수 있습니다.

SQLite 간략한 역사

  • 2000-D. Richard Hipp은 프로그램 운영에 필요한 관리가 필요하지 않은 목적으로 SQLite를 설계했습니다.

  • 2000-8 월에 SQLite 1.0이 GNU 데이터베이스 관리자와 함께 출시되었습니다.

  • 2011-Hipp는 SQLite DB에 UNQl 인터페이스를 추가하고 UNQLite (문서 지향 데이터베이스)를 개발한다고 발표했습니다.

SQLite 제한

다음 표에 나열된 SQLite에는 지원되지 않는 SQL92 기능이 거의 없습니다.

Sr. 아니. 기능 및 설명
1

RIGHT OUTER JOIN

LEFT OUTER JOIN 만 구현됩니다.
2

FULL OUTER JOIN

LEFT OUTER JOIN 만 구현됩니다.
삼

ALTER TABLE

ALTER TABLE 명령의 RENAME TABLE 및 ADD COLUMN 변형이 지원됩니다. DROP COLUMN, ALTER COLUMN, ADD CONSTRAINT는 지원되지 않습니다.
4

Trigger support

FOR EACH ROW 트리거는 지원되지만 FOR EACH STATEMENT 트리거는 지원되지 않습니다.
5

VIEWs

SQLite의 VIEW는 읽기 전용입니다. 뷰에서 DELETE, INSERT 또는 UPDATE 문을 실행할 수 없습니다.
6

GRANT and REVOKE

적용 할 수있는 유일한 액세스 권한은 기본 운영 체제의 일반 파일 액세스 권한입니다.

SQLite 명령

관계형 데이터베이스와 상호 작용하는 표준 SQLite 명령은 SQL과 유사합니다. CREATE, SELECT, INSERT, UPDATE, DELETE 및 DROP입니다. 이러한 명령은 작동 특성에 따라 그룹으로 분류 할 수 있습니다.

DDL-데이터 정의 언어

Sr. 아니. 명령 및 설명
1

CREATE

새 테이블, 테이블보기 또는 데이터베이스의 다른 개체를 만듭니다.
2

ALTER

테이블과 같은 기존 데이터베이스 개체를 수정합니다.
삼

DROP

전체 테이블, 테이블 뷰 또는 데이터베이스의 다른 개체를 삭제합니다.

DML-데이터 조작 언어

Sr. 아니. 명령 및 설명
1

INSERT

레코드를 만듭니다.
2

UPDATE

레코드 수정
삼

DELETE

기록 삭제

DQL-데이터 쿼리 언어

Sr. 아니. 명령 및 설명
1

SELECT

하나 이상의 테이블에서 특정 레코드를 검색합니다.

SQLite는 제로 구성 기능의 뛰어난 기능으로 유명하므로 복잡한 설정이나 관리가 필요하지 않습니다. 이 장에서는 Windows, Linux 및 Mac OS X에서 SQLite를 설정하는 과정을 안내합니다.

Windows에 SQLite 설치

  • Step 1− SQLite 다운로드 페이지로 이동하여 Windows 섹션에서 미리 컴파일 된 바이너리를 다운로드합니다.

  • Step 2 − sqlite-shell-win32-*. zip 및 sqlite-dll-win32-*. zip 압축 파일을 다운로드합니다.

  • Step 3 − C : \> sqlite 폴더를 만들고이 폴더에 두 개의 압축 파일 위에 압축을 풀면 sqlite3.def, sqlite3.dll 및 sqlite3.exe 파일이 제공됩니다.

  • Step 4 − PATH 환경 변수에 C : \> sqlite를 추가하고 마지막으로 명령 프롬프트로 이동하여 sqlite3 명령을 실행하면 다음 결과가 표시됩니다.

C:\>sqlite3
SQLite version 3.7.15.2 2013-01-09 11:53:05
Enter ".help" for instructions
Enter SQL statements terminated with a ";"
sqlite>

Linux에 SQLite 설치

오늘날 Linux OS의 거의 모든 버전이 SQLite와 함께 제공됩니다. 따라서 다음 명령을 실행하여 컴퓨터에 SQLite가 이미 설치되어 있는지 확인하십시오.

$sqlite3
SQLite version 3.7.15.2 2013-01-09 11:53:05
Enter ".help" for instructions
Enter SQL statements terminated with a ";"
sqlite>

위의 결과가 표시되지 않으면 Linux 컴퓨터에 SQLite가 설치되어 있지 않은 것입니다. 다음은 SQLite를 설치하는 다음 단계입니다-

  • Step 1− SQLite 다운로드 페이지로 이동하여 소스 코드 섹션에서 sqlite-autoconf-*. tar.gz를 다운로드합니다.

  • Step 2 − 다음 명령을 실행합니다 −

$tar xvfz sqlite-autoconf-3071502.tar.gz
$cd sqlite-autoconf-3071502 $./configure --prefix=/usr/local
$make $make install

위의 명령은 Linux 컴퓨터에 SQLite 설치로 끝납니다. 위에서 설명한대로 확인할 수 있습니다.

Mac OS X에 SQLite 설치

최신 버전의 Mac OS X에는 SQLite가 미리 설치되어 있지만 설치할 수없는 경우 다음 단계를 따르십시오.

  • Step 1− SQLite 다운로드 페이지로 이동하여 소스 코드 섹션에서 sqlite-autoconf-*. tar.gz를 다운로드합니다.

  • Step 2 − 다음 명령을 실행합니다 −

$tar xvfz sqlite-autoconf-3071502.tar.gz $cd sqlite-autoconf-3071502
$./configure --prefix=/usr/local $make
$make install

위의 절차는 Mac OS X 컴퓨터에 SQLite 설치로 끝납니다. 다음 명령을 실행하여 확인할 수 있습니다-

$sqlite3
SQLite version 3.7.15.2 2013-01-09 11:53:05
Enter ".help" for instructions
Enter SQL statements terminated with a ";"
sqlite>

마지막으로 실습을 위해 SQLite 명령을 실행할 수있는 SQLite 명령 프롬프트가 있습니다.

이 장에서는 SQLite 프로그래머가 사용하는 간단하고 유용한 명령에 대해 설명합니다. 이러한 명령을 SQLite 도트 명령이라고하며 이러한 명령의 예외는 세미콜론 (;)으로 끝나지 않아야한다는 것입니다.

간단한 입력부터 시작하겠습니다. sqlite3 명령 프롬프트에서 다양한 SQLite 명령을 실행할 SQLite 명령 프롬프트를 제공합니다.

$sqlite3
SQLite version 3.3.6
Enter ".help" for instructions
sqlite>

사용 가능한 도트 명령 목록을 보려면 언제든지 ".help"를 입력 할 수 있습니다. 예를 들면-

sqlite>.help

위의 명령은 다음 표에 나열된 다양한 중요한 SQLite 도트 명령 목록을 표시합니다.

Sr. 아니. 명령 및 설명
1

.backup ?DB? FILE

DB (기본값 "main")를 FILE로 백업
2

.bail ON|OFF

오류가 발생한 후 중지하십시오. 기본값 : 꺼짐
삼

.databases

연결된 데이터베이스의 이름 및 파일 나열
4

.dump ?TABLE?

SQL 텍스트 형식으로 데이터베이스를 덤프합니다. TABLE이 지정된 경우 LIKE 패턴 TABLE과 일치하는 테이블 만 덤프
5

.echo ON|OFF

명령 에코 켜기 또는 끄기
6

.exit

SQLite 프롬프트 종료
7

.explain ON|OFF

EXPLAIN에 적합한 출력 모드를 켜거나 끕니다. 인수가 없으면 EXPLAIN이 켜집니다.
8

.header(s) ON|OFF

헤더 표시 켜기 또는 끄기
9

.help

이 메시지 표시
10

.import FILE TABLE

FILE에서 TABLE로 데이터 가져 오기
11

.indices ?TABLE?

모든 인덱스의 이름을 표시합니다. TABLE이 지정된 경우 LIKE 패턴 TABLE과 일치하는 테이블에 대한 색인 만 표시합니다.
12

.load FILE ?ENTRY?

확장 라이브러리로드
13

.log FILE|off

로깅을 켜거나 끕니다. FILE은 stderr / stdout 일 수 있습니다.
14

.mode MODE

MODE가 다음 중 하나 인 출력 모드를 설정합니다.

  • csv − 쉼표로 구분 된 값

  • column − 왼쪽 정렬 열.

  • html − HTML <table> 코드

  • insert − TABLE에 대한 SQL 삽입 문

  • line − 한 줄에 하나의 값

  • list − .separator 문자열로 구분 된 값

  • tabs − 탭으로 구분 된 값

  • tcl − TCL 목록 요소
15

.nullvalue STRING

NULL 값 대신 STRING 인쇄
16

.output FILENAME

FILENAME에 출력 보내기
17

.output stdout

화면에 출력 보내기
18

.print STRING...

리터럴 STRING 인쇄
19

.prompt MAIN CONTINUE

표준 프롬프트 교체
20

.quit

SQLite 프롬프트 종료
21

.read FILENAME

FILENAME에서 SQL 실행
22

.schema ?TABLE?

CREATE 문을 표시합니다. TABLE이 지정된 경우 LIKE 패턴 TABLE과 일치하는 테이블 만 표시합니다.
23

.separator STRING

출력 모드 및 .import에서 사용하는 구분 기호 변경
24

.show

다양한 설정에 대한 현재 값 표시
25

.stats ON|OFF

통계 켜기 또는 끄기
26

.tables ?PATTERN?

LIKE 패턴과 일치하는 테이블 이름 나열
27

.timeout MS

MS 밀리 초 동안 잠긴 테이블을 열어보십시오.
28

.width NUM NUM

"열"모드에 대한 열 너비 설정
29

.timer ON|OFF

CPU 타이머 측정 켜기 또는 끄기

해보자 .show 명령을 사용하여 SQLite 명령 프롬프트의 기본 설정을 확인하십시오.

sqlite>.show
     echo: off
  explain: off
  headers: off
     mode: column
nullvalue: ""
   output: stdout
separator: "|"
    width:
sqlite>

sqlite> 프롬프트와 점 명령 사이에 공백이 없는지 확인하십시오. 그렇지 않으면 작동하지 않습니다.

출력 형식 지정

다음과 같은 도트 명령 시퀀스를 사용하여 출력 형식을 지정할 수 있습니다.

sqlite>.header on
sqlite>.mode column
sqlite>.timer on
sqlite>

위의 설정은 다음 형식으로 출력을 생성합니다.

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0
CPU Time: user 0.000000 sys 0.000000

sqlite_master 테이블

마스터 테이블은 데이터베이스 테이블에 대한 주요 정보를 보유하고 있으며 sqlite_master. 다음과 같이 스키마를 볼 수 있습니다-

sqlite>.schema sqlite_master

그러면 다음과 같은 결과가 생성됩니다.

CREATE TABLE sqlite_master (
   type text,
   name text,
   tbl_name text,
   rootpage integer,
   sql text
);

SQLite는 Syntax라는 고유 한 규칙 및 지침 집합을 따릅니다. 이 장에서는 모든 기본 SQLite 구문을 나열합니다.

대소 문자 구분

주목해야 할 중요한 점은 SQLite가 case insensitive, 즉 조항 GLOB 과 glob SQLite 문에서 동일한 의미를 갖습니다.

코멘트

SQLite 주석은 가독성을 높이기 위해 SQLite 코드에 추가 할 수있는 추가 메모이며 어디서나 나타날 수 있습니다. 내부 표현식과 다른 SQL 문 중간을 포함하여 공백이 발생할 수 있지만 중첩 될 수는 없습니다.

SQL 주석은 두 개의 연속 "-"문자 (ASCII 0x2d)로 시작하고 다음 개행 문자 (ASCII 0x0a)까지 또는 입력이 끝날 때까지 확장됩니다.

또한 "/ *"로 시작하고 다음 "* /"문자 쌍까지 또는 입력 끝까지 확장되는 C 스타일 주석을 사용할 수도 있습니다. C 스타일 주석은 여러 줄에 걸쳐있을 수 있습니다.

sqlite> .help -- This is a single line comment

SQLite 문

모든 SQLite 문은 SELECT, INSERT, UPDATE, DELETE, ALTER, DROP 등과 같은 키워드로 시작하고 모든 문은 세미콜론 (;)으로 끝납니다.

SQLite ANALYZE 문

ANALYZE;
or
ANALYZE database_name;
or
ANALYZE database_name.table_name;

SQLite AND / OR 절

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

SQLite ALTER TABLE 문

ALTER TABLE table_name ADD COLUMN column_def...;

SQLite ALTER TABLE 문 (이름 바꾸기)

ALTER TABLE table_name RENAME TO new_table_name;

SQLite ATTACH DATABASE 문

ATTACH DATABASE 'DatabaseName' As 'Alias-Name';

SQLite BEGIN TRANSACTION 문

BEGIN;
or
BEGIN EXCLUSIVE TRANSACTION;

SQLite BETWEEN 절

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

SQLite COMMIT 문

COMMIT;

SQLite CREATE INDEX 문

CREATE INDEX index_name
ON table_name ( column_name COLLATE NOCASE );

SQLite CREATE UNIQUE INDEX 문

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

SQLite CREATE TABLE 문

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

SQLite CREATE TRIGGER 문

CREATE TRIGGER database_name.trigger_name 
BEFORE INSERT ON table_name FOR EACH ROW
BEGIN 
   stmt1; 
   stmt2;
   ....
END;

SQLite CREATE VIEW 문

CREATE VIEW database_name.view_name AS
SELECT statement....;

SQLite CREATE VIRTUAL TABLE 문

CREATE VIRTUAL TABLE database_name.table_name USING weblog( access.log );
or
CREATE VIRTUAL TABLE database_name.table_name USING fts3( );

SQLite COMMIT TRANSACTION 문

COMMIT;

SQLite COUNT 절

SELECT COUNT(column_name)
FROM table_name
WHERE CONDITION;

SQLite DELETE 문

DELETE FROM table_name
WHERE {CONDITION};

SQLite DETACH DATABASE 문

DETACH DATABASE 'Alias-Name';

SQLite DISTINCT 절

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

SQLite DROP INDEX 문

DROP INDEX database_name.index_name;

SQLite DROP TABLE 문

DROP TABLE database_name.table_name;

SQLite DROP VIEW 문

DROP INDEX database_name.view_name;

SQLite DROP TRIGGER 문

DROP INDEX database_name.trigger_name;

SQLite EXISTS 절

SELECT column1, column2....columnN
FROM table_name
WHERE column_name EXISTS (SELECT * FROM   table_name );

SQLite EXPLAIN 문

EXPLAIN INSERT statement...;
or 
EXPLAIN QUERY PLAN SELECT statement...;

SQLite GLOB 조항

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

SQLite GROUP BY 절

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

SQLite HAVING 절

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

SQLite INSERT INTO 문

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

SQLite IN 절

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

SQLite Like 절

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

SQLite NOT IN 절

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

SQLite ORDER BY 절

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

SQLite PRAGMA 문

PRAGMA pragma_name;

For example:

PRAGMA page_size;
PRAGMA cache_size = 1024;
PRAGMA table_info(table_name);

SQLite RELEASE SAVEPOINT 문

RELEASE savepoint_name;

SQLite REINDEX 문

REINDEX collation_name;
REINDEX database_name.index_name;
REINDEX database_name.table_name;

SQLite ROLLBACK 문

ROLLBACK;
or
ROLLBACK TO SAVEPOINT savepoint_name;

SQLite SAVEPOINT 문

SAVEPOINT savepoint_name;

SQLite SELECT 문

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

SQLite UPDATE 문

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

SQLite VACUUM 문

VACUUM;

SQLite WHERE 절

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

SQLite 데이터 유형은 모든 객체의 데이터 유형을 지정하는 속성입니다. 각 열, 변수 및 표현식에는 SQLite의 관련 데이터 유형이 있습니다.

테이블을 만드는 동안 이러한 데이터 유형을 사용합니다. SQLite는보다 일반적인 동적 유형 시스템을 사용합니다. SQLite에서 값의 데이터 유형은 컨테이너가 아니라 값 자체와 연관됩니다.

SQLite 스토리지 클래스

SQLite 데이터베이스에 저장된 각 값에는 다음 스토리지 클래스 중 하나가 있습니다.

Sr. 아니. 스토리지 클래스 및 설명
1

NULL

값이 NULL 값입니다.
2

INTEGER

값은 값의 크기에 따라 1, 2, 3, 4, 6 또는 8 바이트에 저장된 부호있는 정수입니다.
삼

REAL

값은 8 바이트 IEEE 부동 소수점 숫자로 저장되는 부동 소수점 값입니다.
4

TEXT

값은 데이터베이스 인코딩 (UTF-8, UTF-16BE 또는 UTF-16LE)을 사용하여 저장된 텍스트 문자열입니다.
5

BLOB

값은 입력 된대로 정확하게 저장된 데이터의 한 덩어리입니다.

SQLite 스토리지 클래스는 데이터 유형보다 약간 더 일반적입니다. 예를 들어, INTEGER 스토리지 클래스에는 길이가 다른 6 가지 정수 데이터 유형이 포함됩니다.

SQLite 선호도 유형

SQLite는 type affinity열에. 모든 열은 여전히 ​​모든 유형의 데이터를 저장할 수 있지만 열에 대해 선호하는 스토리지 클래스를affinity. SQLite3 데이터베이스의 각 테이블 열에는 다음 유형 친 화성 중 하나가 할당됩니다.

Sr. 아니. 선호도 및 설명
1

TEXT

이 열은 스토리지 클래스 NULL, TEXT 또는 BLOB를 사용하여 모든 데이터를 저장합니다.
2

NUMERIC

이 열에는 5 개의 스토리지 클래스를 모두 사용하는 값이 포함될 수 있습니다.
삼

INTEGER

CAST 표현식의 예외를 제외하고 NUMERIC 선호도가있는 열과 동일하게 작동합니다.
4

REAL

정수 값을 부동 소수점 표현으로 강제한다는 점을 제외하면 선호도가 NUMERIC 인 열처럼 작동합니다.
5

NONE

선호도가 NONE 인 열은 한 스토리지 클래스를 다른 스토리지 클래스보다 선호하지 않으며 한 스토리지 클래스에서 다른 스토리지 클래스로 데이터를 강제 변환하지 않습니다.

SQLite 선호도 및 유형 이름

다음 표에는 해당하는 선호도를 적용하여 SQLite3 테이블을 생성하는 동안 사용할 수있는 다양한 데이터 유형 이름이 나열되어 있습니다.

데이터 형식 유연
  • INT
  • INTEGER
  • TINYINT
  • SMALLINT
  • MEDIUMINT
  • BIGINT
  • 서명되지 않은 BIG INT
  • INT2
  • INT8
 정수
  • CHARACTER(20)
  • VARCHAR(255)
  • 다양한 캐릭터 (255)
  • NCHAR(55)
  • 네이티브 캐릭터 (70)
  • NVARCHAR(100)
  • TEXT
  • CLOB
 본문
  • BLOB
  • 지정된 데이터 유형이 없습니다.
 없음
  • REAL
  • DOUBLE
  • 이중 정밀도
  • FLOAT
 레알
  • NUMERIC
  • DECIMAL(10,5)
  • BOOLEAN
  • DATE
  • DATETIME
 숫자

부울 데이터 유형

SQLite에는 별도의 부울 저장소 클래스가 없습니다. 대신 부울 값은 정수 0 (거짓) 및 1 (참)로 저장됩니다.

날짜 및 시간 데이터 유형

SQLite에는 날짜 및 / 또는 시간을 저장하기위한 별도의 저장소 클래스가 없지만 SQLite는 날짜와 시간을 TEXT, REAL 또는 INTEGER 값으로 저장할 수 있습니다.

Sr. 아니. 스토리지 클래스 및 날짜 형식
1

TEXT

"YYYY-MM-DD HH : MM : SS.SSS"와 같은 형식의 날짜
2

REAL

기원전 4714 년 11 월 24 일 그리니치 정오 이후의 일수
삼

INTEGER

1970-01-01 00:00:00 UTC 이후의 초 수

이러한 형식 중 하나로 날짜와 시간을 저장하고 내장 된 날짜 및 시간 함수를 사용하여 형식간에 자유롭게 변환 할 수 있습니다.

SQLite에서 sqlite3명령은 새 SQLite 데이터베이스를 만드는 데 사용됩니다. 데이터베이스를 생성하기 위해 특별한 권한이 필요하지 않습니다.

통사론

다음은 데이터베이스를 생성하는 sqlite3 명령의 기본 구문입니다. −

$sqlite3 DatabaseName.db

항상 데이터베이스 이름은 RDBMS 내에서 고유해야합니다.

예

새 데이터베이스 <testDB.db>를 생성하려는 경우 SQLITE3 문은 다음과 같습니다.

$sqlite3 testDB.db
SQLite version 3.7.15.2 2013-01-09 11:53:05
Enter ".help" for instructions
Enter SQL statements terminated with a ";"
sqlite>

위의 명령은 파일을 생성합니다 testDB.db현재 디렉토리에서. 이 파일은 SQLite 엔진에서 데이터베이스로 사용됩니다. 데이터베이스를 생성하는 동안 눈치 채 셨다면 sqlite3 명령은sqlite> 데이터베이스 파일을 성공적으로 생성 한 후 프롬프트.

데이터베이스가 생성되면 다음 SQLite를 사용하여 데이터베이스 목록에서 확인할 수 있습니다. .databases 명령.

sqlite>.databases
seq  name             file
---  ---------------  ----------------------
0    main             /home/sqlite/testDB.db

SQLite를 사용합니다. .quit 다음과 같이 sqlite 프롬프트에서 나오는 명령-

sqlite>.quit
$

.dump 명령

당신이 사용할 수있는 .dump dot 명령은 명령 프롬프트에서 다음 SQLite 명령을 사용하여 전체 데이터베이스를 텍스트 파일로 내 보냅니다.

$sqlite3 testDB.db .dump > testDB.sql

위의 명령은 전체 내용을 변환합니다. testDB.db 데이터베이스를 SQLite 문에 넣고 ASCII 텍스트 파일로 덤프 testDB.sql. 다음과 같이 간단한 방법으로 생성 된 testDB.sql에서 복원을 수행 할 수 있습니다.

$sqlite3 testDB.db < testDB.sql

현재 데이터베이스가 비어 있으므로 데이터베이스에 테이블과 데이터가 거의 없으면 위의 두 가지 절차를 시도 할 수 있습니다. 지금은 다음 장으로 넘어가겠습니다.

여러 데이터베이스를 사용할 수 있고 한 번에 하나를 사용하려는 경우를 고려하십시오. SQLiteATTACH DATABASE 문은 특정 데이터베이스를 선택하는 데 사용되며이 명령 후에는 모든 SQLite 문이 연결된 데이터베이스에서 실행됩니다.

통사론

다음은 SQLite ATTACH DATABASE 문의 기본 구문입니다.

ATTACH DATABASE 'DatabaseName' As 'Alias-Name';

위의 명령은 데이터베이스가 아직 생성되지 않은 경우에도 데이터베이스를 생성합니다. 그렇지 않으면 논리적 데이터베이스 'Alias-Name'과 함께 데이터베이스 파일 이름을 첨부합니다.

예

기존 데이터베이스를 연결하려는 경우 testDB.db, ATTACH DATABASE 문은 다음과 같습니다.

sqlite> ATTACH DATABASE 'testDB.db' as 'TEST';

SQLite 사용 .database 연결된 데이터베이스를 표시하는 명령입니다.

sqlite> .database
seq  name             file
---  ---------------  ----------------------
0    main             /home/sqlite/testDB.db
2    test             /home/sqlite/testDB.db

데이터베이스 이름 main 과 temp임시 테이블 및 기타 임시 데이터 개체를 보유하기 위해 기본 데이터베이스 및 데이터베이스 용으로 예약되어 있습니다. 이 두 데이터베이스 이름은 모든 데이터베이스 연결에 존재하며 연결에 사용해서는 안됩니다. 그렇지 않으면 다음 경고 메시지가 표시됩니다.

sqlite> ATTACH DATABASE 'testDB.db' as 'TEMP';
Error: database TEMP is already in use
sqlite> ATTACH DATABASE 'testDB.db' as 'main';
Error: database TEMP is already in use

SQLite DETACH DATABASE문은 이전에 ATTACH 문을 사용하여 연결된 데이터베이스 연결에서 명명 된 데이터베이스를 분리하고 분리하는 데 사용됩니다. 동일한 데이터베이스 파일이 여러 별명으로 첨부 된 경우 DETACH 명령은 주어진 이름 만 연결 해제하고 나머지 첨부는 계속됩니다. 분리 할 수 ​​없습니다main 또는 temp 데이터베이스.

데이터베이스가 메모리 내 또는 임시 데이터베이스 인 경우 데이터베이스가 손상되고 내용이 손실됩니다.

통사론

다음은 SQLite DETACH DATABASE 'Alias-Name'문의 기본 구문입니다.

DETACH DATABASE 'Alias-Name';

여기서 'Alias-Name'은 ATTACH 문을 사용하여 데이터베이스를 연결할 때 사용한 것과 동일한 별칭입니다.

예

이전 장에서 만든 데이터베이스가 있고 'test'및 'currentDB'를 사용하여 연결 한 것을 고려하십시오. .database 명령.

sqlite>.databases
seq  name             file
---  ---------------  ----------------------
0    main             /home/sqlite/testDB.db
2    test             /home/sqlite/testDB.db
3    currentDB        /home/sqlite/testDB.db

다음 명령을 사용하여 testDB.db에서 'currentDB'를 분리 해 보겠습니다.

sqlite> DETACH DATABASE 'currentDB';

이제 현재 첨부 파일을 확인하면 testDB.db가 여전히 'test'및 'main'과 연결되어 있음을 알 수 있습니다.

sqlite>.databases
seq  name             file
---  ---------------  ----------------------
0    main             /home/sqlite/testDB.db
2    test             /home/sqlite/testDB.db

SQLite CREATE TABLE문은 주어진 데이터베이스에서 새 테이블을 만드는 데 사용됩니다. 기본 테이블을 만들려면 테이블 이름을 지정하고 해당 열과 각 열의 데이터 유형을 정의해야합니다.

통사론

다음은 CREATE TABLE 문의 기본 구문입니다.

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

CREATE TABLE은 데이터베이스 시스템에 새 테이블을 생성하도록 지시하는 키워드입니다. 테이블의 고유 이름 또는 식별자는 CREATE TABLE 문 뒤에옵니다. 선택적 으로 table_name 과 함께 database_name 을 지정할 수 있습니다 .

예

다음은 ID를 기본 키로 사용하여 COMPANY 테이블을 생성하는 예이며 NOT NULL은이 테이블에 레코드를 생성하는 동안 이러한 필드가 NULL이 될 수 없음을 보여주는 제약 조건입니다.

sqlite> CREATE TABLE COMPANY(
   ID INT PRIMARY KEY     NOT NULL,
   NAME           TEXT    NOT NULL,
   AGE            INT     NOT NULL,
   ADDRESS        CHAR(50),
   SALARY         REAL
);

다음 장의 연습에서 사용할 테이블을 하나 더 만들어 보겠습니다.

sqlite> CREATE TABLE DEPARTMENT(
   ID INT PRIMARY KEY      NOT NULL,
   DEPT           CHAR(50) NOT NULL,
   EMP_ID         INT      NOT NULL
);

SQLite 명령을 사용하여 테이블이 성공적으로 생성되었는지 확인할 수 있습니다. .tables 명령은 연결된 데이터베이스의 모든 테이블을 나열하는 데 사용됩니다.

sqlite>.tables
COMPANY     DEPARTMENT

여기서 COMPANY 테이블은 주 데이터베이스에 대한 COMPANY 테이블과 testDB.db에 대해 생성 된 'test'별칭에 대한 test.COMPANY 테이블을 표시하기 때문에 두 번 볼 수 있습니다. 다음 SQLite를 사용하여 테이블에 대한 완전한 정보를 얻을 수 있습니다..schema 명령.

sqlite>.schema COMPANY
CREATE TABLE COMPANY(
   ID INT PRIMARY KEY     NOT NULL,
   NAME           TEXT    NOT NULL,
   AGE            INT     NOT NULL,
   ADDRESS        CHAR(50),
   SALARY         REAL
);

SQLite DROP TABLE 문은 테이블 정의 및 해당 테이블에 대한 모든 관련 데이터, 인덱스, 트리거, 제약 조건 및 권한 사양을 제거하는 데 사용됩니다.

테이블이 삭제되면 테이블에서 사용 가능한 모든 정보도 영원히 손실되므로이 명령을 사용하는 동안주의해야합니다.

통사론

다음은 DROP TABLE 문의 기본 구문입니다. 다음과 같이 테이블 이름과 함께 데이터베이스 이름을 선택적으로 지정할 수 있습니다.

DROP TABLE database_name.table_name;

예

먼저 COMPANY 테이블을 확인한 다음 데이터베이스에서 삭제하겠습니다.

sqlite>.tables
COMPANY       test.COMPANY

이것은 COMPANY 테이블이 데이터베이스에서 사용 가능하다는 것을 의미하므로 다음과 같이 삭제하겠습니다.

sqlite>DROP TABLE COMPANY;
sqlite>

이제 .TABLES 명령을 시도하면 더 이상 COMPANY 테이블을 찾을 수 없습니다.

sqlite>.tables
sqlite>

데이터베이스의 테이블이 성공적으로 삭제되었음을 의미하는 것은 아무것도 표시하지 않습니다.

SQLite INSERT INTO 문은 데이터베이스의 테이블에 새 데이터 행을 추가하는 데 사용됩니다.

통사론

다음은 INSERT INTO 문의 두 가지 기본 구문입니다.

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

여기에서 column1, column2, ... columnN은 데이터를 삽입 할 테이블의 열 이름입니다.

테이블의 모든 열에 대한 값을 추가하는 경우 SQLite 쿼리에 열 이름을 지정할 필요가 없습니다. 그러나 값의 순서가 테이블의 열과 동일한 순서인지 확인하십시오. SQLite INSERT INTO 구문은 다음과 같습니다.

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

예

다음과 같이 testDB.db에 COMPANY 테이블을 이미 생성했다고 가정하십시오.

sqlite> CREATE TABLE COMPANY(
   ID INT PRIMARY KEY     NOT NULL,
   NAME           TEXT    NOT NULL,
   AGE            INT     NOT NULL,
   ADDRESS        CHAR(50),
   SALARY         REAL
);

이제 다음 문은 COMPANY 테이블에 6 개의 레코드를 만듭니다.

INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY)
VALUES (1, 'Paul', 32, 'California', 20000.00 );

INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY)
VALUES (2, 'Allen', 25, 'Texas', 15000.00 );

INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY)
VALUES (3, 'Teddy', 23, 'Norway', 20000.00 );

INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY)
VALUES (4, 'Mark', 25, 'Rich-Mond ', 65000.00 );

INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY)
VALUES (5, 'David', 27, 'Texas', 85000.00 );

INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY)
VALUES (6, 'Kim', 22, 'South-Hall', 45000.00 );

다음과 같이 두 번째 구문을 사용하여 COMPANY 테이블에 레코드를 만들 수 있습니다.

INSERT INTO COMPANY VALUES (7, 'James', 24, 'Houston', 10000.00 );

위의 모든 문은 COMPANY 테이블에 다음 레코드를 생성합니다. 다음 장에서는 테이블에서 이러한 모든 레코드를 표시하는 방법을 배웁니다.

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0

다른 테이블을 사용하여 하나의 테이블 채우기

다른 테이블에 첫 번째 테이블을 채우는 데 필요한 필드 세트가있는 경우 다른 테이블에 대해 select 문을 통해 테이블에 데이터를 채울 수 있습니다. 다음은 구문입니다.

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

지금은 위의 설명을 건너 뛸 수 있습니다. 먼저 다음 장에서 다룰 SELECT 및 WHERE 절에 대해 알아 보겠습니다.

SQLite SELECT문은 결과 테이블 형태로 데이터를 반환하는 SQLite 데이터베이스 테이블에서 데이터를 가져 오는 데 사용됩니다. 이러한 결과 테이블은result sets.

통사론

다음은 SQLite SELECT 문의 기본 구문입니다.

SELECT column1, column2, columnN FROM table_name;

여기서 column1, column2 ...는 값을 가져 오려는 테이블의 필드입니다. 필드에서 사용 가능한 모든 필드를 가져 오려면 다음 구문을 사용할 수 있습니다.

SELECT * FROM table_name;

예

다음 레코드가있는 COMPANY 테이블을 고려하십시오.

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0

다음은 SELECT 문을 사용하여 이러한 모든 레코드를 가져 와서 표시하는 예입니다. 여기에서 처음 세 개의 명령은 올바른 형식의 출력을 설정하는 데 사용되었습니다.

sqlite>.header on
sqlite>.mode column
sqlite> SELECT * FROM COMPANY;

마지막으로 다음과 같은 결과를 얻을 수 있습니다.

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0

COMPANY 테이블의 선택된 필드 만 가져 오려면 다음 쿼리를 사용하십시오.

sqlite> SELECT ID, NAME, SALARY FROM COMPANY;

위의 쿼리는 다음 결과를 생성합니다.

ID          NAME        SALARY
----------  ----------  ----------
1           Paul        20000.0
2           Allen       15000.0
3           Teddy       20000.0
4           Mark        65000.0
5           David       85000.0
6           Kim         45000.0
7           James       10000.0

출력 열 너비 설정

때로는 다음과 같은 경우 잘린 출력과 관련된 문제가 발생합니다. .mode column표시 할 열의 기본 너비 때문에 발생합니다. 할 수있는 것은 다음을 사용하여 열 표시 가능한 열 너비를 설정할 수 있습니다..width num, num.... 다음과 같이 명령-

sqlite>.width 10, 20, 10
sqlite>SELECT * FROM COMPANY;

위 .width 명령은 첫 번째 열 너비를 10, 두 번째 열 너비를 20, 세 번째 열 너비를 10으로 설정합니다. 마지막으로 위의 SELECT 문은 다음과 같은 결과를 제공합니다.

ID          NAME                  AGE         ADDRESS     SALARY
----------  --------------------  ----------  ----------  ----------
1           Paul                  32          California  20000.0
2           Allen                 25          Texas       15000.0
3           Teddy                 23          Norway      20000.0
4           Mark                  25          Rich-Mond   65000.0
5           David                 27          Texas       85000.0
6           Kim                   22          South-Hall  45000.0
7           James                 24          Houston     10000.0

스키마 정보

모두 dot commands SQLite 프롬프트에서 사용할 수 있으므로 SQLite로 프로그래밍하는 동안 다음 SELECT 문을 사용합니다. sqlite_master 데이터베이스에 생성 된 모든 테이블을 나열합니다.

sqlite> SELECT tbl_name FROM sqlite_master WHERE type = 'table';

testDB.db에 COMPANY 테이블 만 있다고 가정하면 다음과 같은 결과가 생성됩니다.

tbl_name
----------
COMPANY

다음과 같이 COMPANY 테이블에 대한 전체 정보를 나열 할 수 있습니다.

sqlite> SELECT sql FROM sqlite_master WHERE type = 'table' AND tbl_name = 'COMPANY';

testDB.db에 COMPANY 테이블 만 있다고 가정하면 다음과 같은 결과가 생성됩니다.

CREATE TABLE COMPANY(
   ID INT PRIMARY KEY     NOT NULL,
   NAME           TEXT    NOT NULL,
   AGE            INT     NOT NULL,
   ADDRESS        CHAR(50),
   SALARY         REAL
)

SQLite의 연산자는 무엇입니까?

연산자는 예약어 또는 주로 SQLite 문의 WHERE 절에서 비교 및 ​​산술 연산과 같은 연산을 수행하는 데 사용되는 문자입니다.

연산자는 SQLite 문에서 조건을 지정하고 명령문에서 여러 조건에 대한 접속사 역할을하는 데 사용됩니다.

  • 산술 연산자
  • 비교 연산자
  • 논리 연산자
  • 비트 연산자

SQLite 산술 연산자

변수 가정 a 10 개와 가변 b 20을 보유하면 SQLite 산술 연산자가 다음과 같이 사용됩니다.

예시보기

운영자 기술 예
+ (추가) 연산자의 양쪽에 값을 추가합니다. a + b는 30을 줄 것입니다
-(빼기) 왼쪽 피연산자에서 오른쪽 피연산자를 뺍니다. a-b는 -10을 줄 것입니다.
* (곱하기) 연산자의 양쪽에 값을 곱합니다. a * b는 200을 줄 것입니다
/ (나누기) 왼손 피연산자를 오른손 피연산자로 나눕니다. b / a는 2를 줄 것입니다
% (모듈러스) 왼쪽 피연산자를 오른쪽 피연산자로 나누고 나머지를 반환합니다. b % a는 0을 제공합니다.

SQLite 비교 연산자

변수 가정 a 10 개와 가변 b 20을 보유하면 SQLite 비교 연산자가 다음과 같이 사용됩니다.

예시보기

운영자 기술 예
== 두 피연산자의 값이 같은지 확인하고, 그렇다면 조건이 참이됩니다. (a == b)는 사실이 아닙니다.
= 두 피연산자의 값이 같은지 확인하고, 그렇다면 조건이 참이됩니다. (a = b)는 사실이 아닙니다.
! = 두 피연산자의 값이 같은지 확인하고, 값이 같지 않으면 조건이 참이됩니다. (a! = b)는 참입니다.
<> 두 피연산자의 값이 같은지 확인하고, 값이 같지 않으면 조건이 참이됩니다. (a <> b)가 참입니다.
> 왼쪽 피연산자의 값이 오른쪽 피연산자의 값보다 큰지 확인하고, 그렇다면 조건이 참이됩니다. (a> b)는 사실이 아닙니다.
< 왼쪽 피연산자의 값이 오른쪽 피연산자의 값보다 작은 지 확인하고, 그렇다면 조건이 참이됩니다. (a <b)는 참입니다.
> = 왼쪽 피연산자의 값이 오른쪽 피연산자의 값보다 크거나 같은지 확인하고, 그렇다면 조건이 참이됩니다. (a> = b)는 사실이 아닙니다.
<= 왼쪽 피연산자의 값이 오른쪽 피연산자의 값보다 작거나 같은지 확인하고, 예이면 조건이 참이됩니다. (a <= b)는 참입니다.
! < 왼쪽 피연산자의 값이 오른쪽 피연산자의 값보다 작지 않은지 확인하고, 그렇다면 조건이 참이됩니다. (a! <b)는 거짓입니다.
!> 왼쪽 피연산자의 값이 오른쪽 피연산자의 값보다 크지 않은지 확인하고, 그렇다면 조건이 참이됩니다. (a!> b)는 참입니다.

SQLite 논리 연산자

다음은 SQLite에서 사용할 수있는 모든 논리 연산자의 목록입니다.

예시보기

Sr. 아니. 연산자 및 설명
1

AND

AND 연산자를 사용하면 SQL 문의 WHERE 절에 여러 조건이있을 수 있습니다.
2

BETWEEN

BETWEEN 연산자는 최소값과 최대 값이 주어진 경우 값 집합 내에있는 값을 검색하는 데 사용됩니다.
삼

EXISTS

EXISTS 연산자는 지정된 테이블에서 특정 기준을 충족하는 행이 있는지 검색하는 데 사용됩니다.
4

IN

IN 연산자는 값을 지정된 리터럴 값 목록과 비교하는 데 사용됩니다.
5

NOT IN

값을 지정된 리터럴 값 목록과 비교하는 데 사용되는 IN 연산자의 부정입니다.
6

LIKE

LIKE 연산자는 와일드 카드 연산자를 사용하여 값을 유사한 값과 비교하는 데 사용됩니다.
7

GLOB

GLOB 연산자는 와일드 카드 연산자를 사용하여 값을 유사한 값과 비교하는 데 사용됩니다. 또한 GLOB는 LIKE와 달리 대소 문자를 구분합니다.
8

NOT

NOT 연산자는 사용되는 논리 연산자의 의미를 반대로합니다. 예 : 존재하지 않음, 사이에 없음, 안으로 없음 등This is negate operator.
9

OR

OR 연산자는 SQL 문의 WHERE 절에서 여러 조건을 결합하는 데 사용됩니다.
10

IS NULL

NULL 연산자는 값을 NULL 값과 비교하는 데 사용됩니다.
11

IS

IS 연산자는 =
12

IS NOT

IS 연산자는! =처럼 작동합니다.
13

||

두 개의 다른 문자열을 추가하고 새로 만듭니다.
14

UNIQUE

UNIQUE 연산자는 지정된 테이블의 모든 행에서 고유성을 검색합니다 (중복 없음).

SQLite 비트 연산자

비트 연산자는 비트에서 작동하고 비트 단위 연산을 수행합니다. 다음은 진리표입니다.& 과 |.

피 큐 p & q p | 큐
0 0 0 0
0 1 0 1
1 1 1 1
1 0 0 1

가정 A= 60; 과B = 13이면 바이너리 형식으로 다음과 같습니다.

A = 0011 1100

B = 0000 1101

-----------------

A & B = 0000 1100

A | B = 0011 1101

~ A = 1100 0011

SQLite 언어에서 지원하는 Bitwise 연산자는 다음 표에 나열되어 있습니다. 변수 가정A 60 개와 가변 B 13을 보유하면-

예시보기

운영자 기술 예
& 이진 AND 연산자는 두 피연산자에 모두있는 경우 결과에 비트를 복사합니다. (A & B)는 0000 1100 인 12를 줄 것입니다.
| 이진 OR 연산자는 피연산자 중 하나에 있으면 비트를 복사합니다. (A | B)는 0011 1101 인 61을 제공합니다.
~ Binary Ones Complement Operator는 단항이며 비트를 '뒤집는'효과가 있습니다. (~ A)는 부호있는 이진수로 인해 2의 보수 형식으로 1100 0011 인 -61을 제공합니다.
<< 이진 왼쪽 시프트 연산자. 왼쪽 피연산자 값은 오른쪽 피연산자에 지정된 비트 수만큼 왼쪽으로 이동합니다. << 2는 1111 0000 인 240을 제공합니다.
>> 이진 오른쪽 시프트 연산자. 왼쪽 피연산자 값은 오른쪽 피연산자에 지정된 비트 수만큼 오른쪽으로 이동합니다. A >> 2는 0000 1111 인 15를 제공합니다.

표현식은 값으로 평가되는 하나 이상의 값, 연산자 및 SQL 함수의 조합입니다.

SQL 식은 수식과 같으며 쿼리 언어로 작성됩니다. 를 사용하여 데이터베이스에서 특정 데이터 집합을 쿼리 할 수도 있습니다.

통사론

다음과 같이 SELECT 문의 기본 구문을 고려하십시오-

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

다음은 다양한 유형의 SQLite 표현식입니다.

SQLite-부울 표현식

SQLite Boolean Expressions는 일치하는 단일 값을 기준으로 데이터를 가져옵니다. 다음은 구문입니다-

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

다음 레코드가있는 COMPANY 테이블을 고려하십시오.

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0

다음은 SQLite 부울 표현식의 사용법을 보여주는 간단한 예입니다.

sqlite> SELECT * FROM COMPANY WHERE SALARY = 10000;

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
4           James        24          Houston   10000.0

SQLite-숫자 식

이러한 식은 모든 쿼리에서 수학적 연산을 수행하는 데 사용됩니다. 다음은 구문입니다-

SELECT numerical_expression as OPERATION_NAME
[FROM table_name WHERE CONDITION] ;

여기서 numeric_expression은 수학적 표현이나 공식에 사용됩니다. 다음은 SQLite Numeric Expressions의 사용법을 보여주는 간단한 예입니다.

sqlite> SELECT (15 + 6) AS ADDITION
ADDITION = 21

다음과 같은 몇 가지 내장 기능이 있습니다. avg(), sum(), count(), 등으로 알려진 것을 수행하기 위해 aggregate data calculations 테이블 또는 특정 테이블 열에 대해.

sqlite> SELECT COUNT(*) AS "RECORDS" FROM COMPANY; 
RECORDS = 7

SQLite-날짜 표현

날짜 표현식은 현재 시스템 날짜 및 시간 값을 반환합니다. 이러한 식은 다양한 데이터 조작에 사용됩니다.

sqlite> SELECT CURRENT_TIMESTAMP;
CURRENT_TIMESTAMP = 2013-03-17 10:43:35

SQLite WHERE 절은 하나의 테이블 또는 여러 테이블에서 데이터를 가져 오는 동안 조건을 지정하는 데 사용됩니다.

주어진 조건이 충족되면 참을 의미하고 테이블에서 특정 값을 반환합니다. 레코드를 필터링하고 필요한 레코드 만 가져 오려면 WHERE 절을 사용해야합니다.

WHERE 절은 SELECT 문에서만 사용되는 것이 아니라 UPDATE, DELETE 문 등에서도 사용되며 이후 장에서 다룹니다.

통사론

다음은 WHERE 절이있는 SQLite SELECT 문의 기본 구문입니다.

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

예

>, <, =, LIKE, NOT 등과 같은 비교 또는 논리 연산자를 사용하여 조건을 지정할 수 있습니다 . 다음 레코드가있는 COMPANY 테이블을 고려하십시오.

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0

다음은 SQLite 논리 연산자의 사용법을 보여주는 간단한 예입니다. 다음 SELECT 문은 AGE가 25보다 크거나 같은 모든 레코드를 나열합니다.AND 급여가 65000.00 이상입니다.

sqlite> SELECT * FROM COMPANY WHERE AGE >= 25 AND SALARY >= 65000;

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0

다음 SELECT 문은 AGE가 25보다 크거나 같은 모든 레코드를 나열합니다. OR 급여가 65000.00 이상입니다.

sqlite> SELECT * FROM COMPANY WHERE AGE >= 25 OR SALARY >= 65000;

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0

다음 SELECT 문은 AGE가 NULL이 아닌 모든 레코드를 나열합니다. 이는 레코드에 NULL과 같은 AGE가 없기 때문에 모든 레코드를 의미합니다.

sqlite>  SELECT * FROM COMPANY WHERE AGE IS NOT NULL;

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0

다음 SELECT 문은 NAME이 'Ki'로 시작하는 모든 레코드를 나열하며 'Ki'뒤에 오는 것은 중요하지 않습니다.

sqlite> SELECT * FROM COMPANY WHERE NAME LIKE 'Ki%';

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
6           Kim         22          South-Hall  45000.0

다음 SELECT 문은 NAME이 'Ki'로 시작하는 모든 레코드를 나열하며 'Ki'뒤에 오는 것은 중요하지 않습니다.

sqlite> SELECT * FROM COMPANY WHERE NAME GLOB 'Ki*';

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
6           Kim         22          South-Hall  45000.0

다음 SELECT 문은 AGE 값이 25 또는 27 인 모든 레코드를 나열합니다.

sqlite> SELECT * FROM COMPANY WHERE AGE IN ( 25, 27 );

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
2           Allen       25          Texas       15000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0

다음 SELECT 문은 AGE 값이 25도 27도 아닌 모든 레코드를 나열합니다.

sqlite> SELECT * FROM COMPANY WHERE AGE NOT IN ( 25, 27 );

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
3           Teddy       23          Norway      20000.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0

다음 SELECT 문은 AGE 값이 BETWEEN 25 AND 27에있는 모든 레코드를 나열합니다.

sqlite> SELECT * FROM COMPANY WHERE AGE BETWEEN 25 AND 27;

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
2           Allen       25          Texas       15000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0

다음 SELECT 문은 SQL 하위 쿼리를 사용합니다. 여기서 하위 쿼리는 SALARY> 65000 이상을 갖는 AGE 필드가있는 모든 레코드를 찾습니다. WHERE 절은 EXISTS 연산자와 함께 사용되어 외부 쿼리의 AGE가있는 모든 레코드를 나열합니다. 하위 쿼리에 의해 반환 된 결과에서-

sqlite> SELECT AGE FROM COMPANY 
   WHERE EXISTS (SELECT AGE FROM COMPANY WHERE SALARY > 65000);

AGE
----------
32
25
23
25
27
22
24

다음 SELECT 문은 하위 쿼리가 SALARY> 65000 이상을 갖는 AGE 필드가있는 모든 레코드를 찾는 SQL 하위 쿼리를 사용하며 WHERE 절이> 연산자와 함께 사용되어 외부 쿼리의 AGE가 더 큰 모든 레코드를 나열합니다. 하위 쿼리가 반환 한 결과의 나이보다

sqlite> SELECT * FROM COMPANY 
   WHERE AGE > (SELECT AGE FROM COMPANY WHERE SALARY > 65000);

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0

SQLite AND & OR연산자는 SQLite 문에서 선택한 데이터의 범위를 좁히기 위해 여러 조건을 컴파일하는 데 사용됩니다. 이 두 연산자는conjunctive operators.

이러한 연산자는 동일한 SQLite 문에서 다른 연산자와 여러 비교를 수행하는 수단을 제공합니다.

AND 연산자

그만큼 AND연산자는 SQLite 문의 WHERE 절에 여러 조건의 존재를 허용합니다. AND 연산자를 사용하는 동안 모든 조건이 참이면 완전한 조건이 참으로 간주됩니다. 예를 들어, [조건 1] AND [조건 2]는 조건 1과 조건 2가 모두 참인 경우에만 참이됩니다.

통사론

다음은 WHERE 절이있는 AND 연산자의 기본 구문입니다.

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

결합 할 수 있습니다. NAND 연산자를 사용하는 조건 수. 트랜잭션이든 쿼리이든 SQLite 문에서 수행 할 작업의 경우 AND로 구분 된 모든 조건은 TRUE 여야합니다.

예

다음 레코드가있는 COMPANY 테이블을 고려하십시오.

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0

다음 SELECT 문은 AGE가 25보다 크거나 같은 모든 레코드를 나열합니다. AND 급여가 65000.00 이상입니다.

sqlite> SELECT * FROM COMPANY WHERE AGE >= 25 AND SALARY >= 65000;

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0

OR 연산자

OR 연산자는 SQLite 문의 WHERE 절에서 여러 조건을 결합하는데도 사용됩니다. OR 연산자를 사용하는 동안 조건 중 하나 이상이 참이면 완전한 조건이 참으로 간주됩니다. 예를 들어 [조건 1] OR [조건 2]는 조건 1 또는 조건 2가 참이면 참이됩니다.

통사론

다음은 WHERE 절이있는 OR 연산자의 기본 구문입니다.

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

결합 할 수 있습니다. NOR 연산자를 사용하는 조건 수. 트랜잭션이든 쿼리이든 SQLite 문이 수행 할 작업의 경우 OR로 구분 된 조건 중 하나만 TRUE 여야합니다.

예

다음 레코드가있는 COMPANY 테이블을 고려하십시오.

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0

다음 SELECT 문은 AGE가 25보다 크거나 같은 모든 레코드를 나열합니다. OR 급여가 65000.00 이상입니다.

sqlite> SELECT * FROM COMPANY WHERE AGE >= 25 OR SALARY >= 65000;

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0

SQLite UPDATE쿼리는 테이블의 기존 레코드를 수정하는 데 사용됩니다. UPDATE 쿼리와 함께 WHERE 절을 사용하여 선택한 행을 업데이트 할 수 있습니다. 그렇지 않으면 모든 행이 업데이트됩니다.

통사론

다음은 WHERE 절이있는 UPDATE 쿼리의 기본 구문입니다.

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

결합 할 수 있습니다. N AND 또는 OR 연산자를 사용하는 조건 수.

예

다음 레코드가있는 COMPANY 테이블을 고려하십시오.

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0

다음은 ID가 6 인 고객의 ADDRESS를 업데이트하는 예입니다.

sqlite> UPDATE COMPANY SET ADDRESS = 'Texas' WHERE ID = 6;

이제 COMPANY 테이블에는 다음 레코드가 있습니다.

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0
6           Kim         22          Texas       45000.0
7           James       24          Houston     10000.0

COMPANY 테이블의 모든 ADDRESS 및 SALARY 열 값을 수정하려는 경우 WHERE 절을 사용할 필요가 없으며 UPDATE 쿼리는 다음과 같습니다.

sqlite> UPDATE COMPANY SET ADDRESS = 'Texas', SALARY = 20000.00;

이제 COMPANY 테이블에는 다음과 같은 레코드가 있습니다.

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          Texas       20000.0
2           Allen       25          Texas       20000.0
3           Teddy       23          Texas       20000.0
4           Mark        25          Texas       20000.0
5           David       27          Texas       20000.0
6           Kim         22          Texas       20000.0
7           James       24          Texas       20000.0

SQLite DELETE쿼리는 테이블에서 기존 레코드를 삭제하는 데 사용됩니다. DELETE 쿼리와 함께 WHERE 절을 사용하여 선택한 행을 삭제할 수 있습니다. 그렇지 않으면 모든 레코드가 삭제됩니다.

통사론

다음은 WHERE 절이있는 DELETE 쿼리의 기본 구문입니다.

DELETE FROM table_name
WHERE [condition];

결합 할 수 있습니다. N AND 또는 OR 연산자를 사용하는 조건 수.

예

다음 레코드가있는 COMPANY 테이블을 고려하십시오.

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0

다음은 ID가 7 인 고객을 삭제하는 예입니다.

sqlite> DELETE FROM COMPANY WHERE ID = 7;

이제 COMPANY 테이블에 다음 레코드가 있습니다.

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0
6           Kim         22          South-Hall  45000.0

COMPANY 테이블의 모든 레코드를 삭제하려면 다음과 같이 DELETE 쿼리에 WHERE 절을 사용할 필요가 없습니다.

sqlite> DELETE FROM COMPANY;

이제 COMPANY 테이블에는 모든 레코드가 DELETE 문에 의해 삭제되었으므로 레코드가 없습니다.

SQLite LIKE연산자는 와일드 카드를 사용하여 패턴에 대해 텍스트 값을 일치시키는 데 사용됩니다. 검색 표현식이 패턴 표현식과 일치 할 수있는 경우 LIKE 연산자는 1 인 true를 리턴합니다. 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_'

결합 할 수 있습니다. NAND 또는 OR 연산자를 사용하는 조건 수. 여기서 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 자리 숫자의 값을 찾습니다.

실제 예를 들어 다음 레코드가있는 COMPANY 테이블을 고려하십시오.

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0

다음은 AGE가 2로 시작하는 COMPANY 테이블의 모든 레코드를 표시하는 예입니다.

sqlite> SELECT * FROM COMPANY WHERE AGE LIKE '2%';

그러면 다음과 같은 결과가 생성됩니다.

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0

다음은 ADDRESS가 텍스트 안에 하이픈 (-)이있는 COMPANY 테이블의 모든 레코드를 표시하는 예입니다.

sqlite> SELECT * FROM COMPANY WHERE ADDRESS  LIKE '%-%';

그러면 다음과 같은 결과가 생성됩니다.

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
4           Mark        25          Rich-Mond   65000.0
6           Kim         22          South-Hall  45000.0

SQLite GLOB연산자는 와일드 카드를 사용하여 패턴에 대해 텍스트 값만 일치시키는 데 사용됩니다. 검색 표현식이 패턴 표현식과 일치 할 수있는 경우 GLOB 연산자는 true (1)를 리턴합니다. LIKE 연산자와 달리 GLOB는 대소 문자를 구분하며 다음 와일드 카드를 지정하기 위해 UNIX 구문을 따릅니다.

  • 별표 (*)
  • 물음표 (?)

별표 기호 (*)는 0 개 또는 여러 개의 숫자 또는 문자를 나타냅니다. 물음표 (?)는 단일 숫자 또는 문자를 나타냅니다.

통사론

다음은 기본 구문입니다. * 과 ?.

SELECT FROM table_name
WHERE column GLOB 'XXXX*'
or 
SELECT FROM table_name
WHERE column GLOB '*XXXX*'
or
SELECT FROM table_name
WHERE column GLOB 'XXXX?'
or
SELECT FROM table_name
WHERE column GLOB '?XXXX'
or
SELECT FROM table_name
WHERE column GLOB '?XXXX?'
or
SELECT FROM table_name
WHERE column GLOB '????'

결합 할 수 있습니다. NAND 또는 OR 연산자를 사용하는 조건 수. 여기서 XXXX는 숫자 또는 문자열 값이 될 수 있습니다.

예

다음 표에는 '*'및 '?'와 함께 서로 다른 LIKE 절이있는 WHERE 부분을 보여주는 여러 예가 나열되어 있습니다. 연산자.

Sr. 아니. 성명 및 설명
1

WHERE SALARY GLOB '200*'

200으로 시작하는 모든 값을 찾습니다.
2

WHERE SALARY GLOB '*200*'

임의의 위치에 200이있는 모든 값을 찾습니다.
삼

WHERE SALARY GLOB '?00*'

두 번째 및 세 번째 위치에 00이있는 모든 값을 찾습니다.
4

WHERE SALARY GLOB '2??'

2로 시작하고 길이가 3 자 이상인 모든 값을 찾습니다.
5

WHERE SALARY GLOB '*2'

2로 끝나는 모든 값을 찾습니다.
6

WHERE SALARY GLOB '?2*3'

두 번째 위치에 2가 있고 3으로 끝나는 값을 찾습니다.
7

WHERE SALARY GLOB '2???3'

2로 시작하고 3으로 끝나는 5 자리 숫자의 값을 찾습니다.

실제 예를 들어 다음 레코드가있는 COMPANY 테이블을 고려해 보겠습니다.

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0

다음은 AGE가 2로 시작하는 COMPANY 테이블의 모든 레코드를 표시하는 예입니다.

sqlite> SELECT * FROM COMPANY WHERE AGE  GLOB '2*';

그러면 다음과 같은 결과가 생성됩니다.

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0

다음은 ADDRESS가 텍스트 안에 하이픈 (-)이있는 COMPANY 테이블의 모든 레코드를 표시하는 예입니다.

sqlite> SELECT * FROM COMPANY WHERE ADDRESS  GLOB '*-*';

그러면 다음과 같은 결과가 생성됩니다.

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
4           Mark        25          Rich-Mond   65000.0
6           Kim         22          South-Hall  45000.0

SQLite LIMIT 절은 SELECT 문이 반환하는 데이터 양을 제한하는 데 사용됩니다.

통사론

다음은 LIMIT 절이있는 SELECT 문의 기본 구문입니다.

SELECT column1, column2, columnN 
FROM table_name
LIMIT [no of rows]

다음은 OFFSET 절과 함께 사용할 때 LIMIT 절의 구문입니다.

SELECT column1, column2, columnN 
FROM table_name
LIMIT [no of rows] OFFSET [row num]

SQLite 엔진은 마지막 예제에서 아래에 표시된 것처럼 다음 행부터 주어진 OFFSET까지 행을 반환합니다.

예

다음 레코드가있는 COMPANY 테이블을 고려하십시오.

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0

다음은 테이블에서 가져 오려는 행 수에 따라 테이블의 행을 제한하는 예입니다.

sqlite> SELECT * FROM COMPANY LIMIT 6;

그러면 다음과 같은 결과가 생성됩니다.

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0
6           Kim         22          South-Hall  45000.0

그러나 특정 상황에서는 특정 오프셋에서 레코드 집합을 선택해야 할 수 있습니다. 다음은 3 번째 위치 에서 시작하여 3 개의 레코드를 선택하는 예 입니다.

sqlite> SELECT * FROM COMPANY LIMIT 3 OFFSET 2;

그러면 다음과 같은 결과가 생성됩니다.

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0

SQLite ORDER BY 절은 하나 이상의 열을 기준으로 오름차순 또는 내림차순으로 데이터를 정렬하는 데 사용됩니다.

통사론

다음은 ORDER BY 절의 기본 구문입니다.

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

ORDER BY 절에서 둘 이상의 열을 사용할 수 있습니다. 정렬에 사용하는 열이 무엇이든 해당 열이 열 목록에서 사용 가능해야합니다.

예

다음 레코드가있는 COMPANY 테이블을 고려하십시오.

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0

다음은 SALARY를 기준으로 결과를 내림차순으로 정렬하는 예입니다.

sqlite> SELECT * FROM COMPANY ORDER BY SALARY ASC;

그러면 다음과 같은 결과가 생성됩니다.

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
7           James       24          Houston     10000.0
2           Allen       25          Texas       15000.0
1           Paul        32          California  20000.0
3           Teddy       23          Norway      20000.0
6           Kim         22          South-Hall  45000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0

다음은 NAME 및 SALARY를 기준으로 결과를 내림차순으로 정렬하는 예입니다.

sqlite> SELECT * FROM COMPANY ORDER BY NAME, SALARY ASC;

그러면 다음과 같은 결과가 생성됩니다.

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
2           Allen       25          Texas       15000.0
5           David       27          Texas       85000.0
7           James       24          Houston     10000.0
6           Kim         22          South-Hall  45000.0
4           Mark        25          Rich-Mond   65000.0
1           Paul        32          California  20000.0
3           Teddy       23          Norway      20000.0

다음은 NAME을 기준으로 결과를 내림차순으로 정렬하는 예입니다.

sqlite> SELECT * FROM COMPANY ORDER BY NAME DESC;

그러면 다음과 같은 결과가 생성됩니다.

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
3           Teddy       23          Norway      20000.0
1           Paul        32          California  20000.0
4           Mark        25          Rich-Mond   65000.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0
5           David       27          Texas       85000.0
2           Allen       25          Texas       15000.0

SQLite GROUP BY 절은 SELECT 문과 협력하여 동일한 데이터를 그룹으로 배열하는 데 사용됩니다.

GROUP BY 절은 SELECT 문에서 WHERE 절 뒤에 나오며 ORDER BY 절 앞에옵니다.

통사론

다음은 GROUP BY 절의 기본 구문입니다. GROUP BY 절은 WHERE 절의 조건을 따라야하며 ORDER BY 절이 사용되는 경우 앞에 와야합니다.

SELECT column-list
FROM table_name
WHERE [ conditions ]
GROUP BY column1, column2....columnN
ORDER BY column1, column2....columnN

GROUP BY 절에 둘 이상의 열을 사용할 수 있습니다. 그룹화하는 데 사용하는 열이 무엇이든 해당 열이 열 목록에서 사용 가능해야합니다.

예

다음 레코드가있는 COMPANY 테이블을 고려하십시오.

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0

각 고객의 총 급여 금액을 알고 싶다면 GROUP BY 쿼리는 다음과 같습니다.

sqlite> SELECT NAME, SUM(SALARY) FROM COMPANY GROUP BY NAME;

이것은 다음 결과를 생성합니다-

NAME        SUM(SALARY)
----------  -----------
Allen       15000.0
David       85000.0
James       10000.0
Kim         45000.0
Mark        65000.0
Paul        20000.0
Teddy       20000.0

이제 다음 INSERT 문을 사용하여 COMPANY 테이블에 세 개의 레코드를 더 만들어 보겠습니다.

INSERT INTO COMPANY VALUES (8, 'Paul', 24, 'Houston', 20000.00 );
INSERT INTO COMPANY VALUES (9, 'James', 44, 'Norway', 5000.00 );
INSERT INTO COMPANY VALUES (10, 'James', 45, 'Texas', 5000.00 );

이제 테이블에 이름이 중복 된 다음 레코드가 있습니다.

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0
8           Paul        24          Houston     20000.0
9           James       44          Norway      5000.0
10          James       45          Texas       5000.0

다시, 동일한 문을 사용하여 다음과 같이 NAME 열을 사용하는 모든 레코드를 그룹화합니다.

sqlite> SELECT NAME, SUM(SALARY) FROM COMPANY GROUP BY NAME ORDER BY NAME;

그러면 다음과 같은 결과가 생성됩니다.

NAME        SUM(SALARY)
----------  -----------
Allen       15000
David       85000
James       20000
Kim         45000
Mark        65000
Paul        40000
Teddy       20000

다음과 같이 GROUP BY 절과 함께 ORDER BY 절을 사용하겠습니다.

sqlite>  SELECT NAME, SUM(SALARY) 
   FROM COMPANY GROUP BY NAME ORDER BY NAME DESC;

그러면 다음과 같은 결과가 생성됩니다.

NAME        SUM(SALARY)
----------  -----------
Teddy       20000
Paul        40000
Mark        65000
Kim         45000
James       20000
David       85000
Allen       15000

HAVING 절을 사용하면 최종 결과에 나타나는 그룹 결과를 필터링하는 조건을 지정할 수 있습니다.

WHERE 절은 선택한 열에 조건을 배치하는 반면 HAVING 절은 GROUP BY 절에 의해 생성 된 그룹에 조건을 배치합니다.

통사론

다음은 SELECT 쿼리에서 HAVING 절의 위치입니다.

SELECT
FROM
WHERE
GROUP BY
HAVING
ORDER BY

HAVING 절은 쿼리에서 GROUP BY 절 뒤에 와야하며 사용되는 경우 ORDER BY 절 앞에 와야합니다. 다음은 HAVING 절을 포함한 SELECT 문의 구문입니다.

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

예

다음 레코드가있는 COMPANY 테이블을 고려하십시오.

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0
8           Paul        24          Houston     20000.0
9           James       44          Norway      5000.0
10          James       45          Texas       5000.0

다음은 이름 개수가 2 미만인 레코드를 표시하는 예입니다.

sqlite > SELECT * FROM COMPANY GROUP BY name HAVING count(name) < 2;

그러면 다음과 같은 결과가 생성됩니다.

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
2           Allen       25          Texas       15000
5           David       27          Texas       85000
6           Kim         22          South-Hall  45000
4           Mark        25          Rich-Mond   65000
3           Teddy       23          Norway      20000

다음은 이름 수가 2보다 큰 레코드를 표시하는 예입니다.

sqlite > SELECT * FROM COMPANY GROUP BY name HAVING count(name) > 2;

그러면 다음과 같은 결과가 생성됩니다.

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
10          James       45          Texas       5000

SQLite DISTINCT 키워드는 SELECT 문과 함께 사용되어 모든 중복 레코드를 제거하고 고유 한 레코드 만 가져옵니다.

테이블에 중복 레코드가 여러 개있는 상황이있을 수 있습니다. 이러한 레코드를 가져 오는 동안 중복 레코드를 가져 오는 대신 고유 한 레코드 만 가져 오는 것이 더 합리적입니다.

통사론

다음은 중복 레코드를 제거하기위한 DISTINCT 키워드의 기본 구문입니다.

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

예

다음 레코드가있는 COMPANY 테이블을 고려하십시오.

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0
8           Paul        24          Houston     20000.0
9           James       44          Norway      5000.0
10          James       45          Texas       5000.0

먼저 다음 SELECT 쿼리가 중복 급여 레코드를 반환하는 방법을 살펴 보겠습니다.

sqlite> SELECT name FROM COMPANY;

그러면 다음과 같은 결과가 생성됩니다.

NAME
----------
Paul
Allen
Teddy
Mark
David
Kim
James
Paul
James
James

이제 DISTINCT 위의 SELECT 쿼리로 키워드를 입력하고 결과를 확인하십시오.

sqlite> SELECT DISTINCT name FROM COMPANY;

중복 항목이없는 다음 결과가 생성됩니다.

NAME
----------
Paul
Allen
Teddy
Mark
David
Kim
James

SQLite PRAGMAcommand는 SQLite 환경 내에서 다양한 환경 변수와 상태 플래그를 제어하는 ​​데 사용되는 특수 명령입니다. PRAGMA 값을 읽을 수 있으며 요구 사항에 따라 설정할 수도 있습니다.

통사론

현재 PRAGMA 값을 쿼리하려면 pragma의 이름을 제공하면됩니다.

PRAGMA pragma_name;

PRAGMA의 새 값을 설정하려면 다음 구문을 사용하십시오.

PRAGMA pragma_name = value;

설정 모드는 이름 또는 동등한 정수일 수 있지만 반환 된 값은 항상 정수입니다.

auto_vacuum Pragma

그만큼 auto_vacuumpragma는 자동 진공 모드를 가져 오거나 설정합니다. 다음은 간단한 구문입니다.

PRAGMA [database.]auto_vacuum;
PRAGMA [database.]auto_vacuum = mode;

어디 mode 다음 중 하나 일 수 있습니다.

Sr. 아니. Pragma 가치 및 설명
1

0 or NONE

자동 진공이 비활성화됩니다. 이것은 데이터베이스 파일이 VACUUM 명령을 사용하여 수동으로 vacuum되지 않는 한 크기가 줄어들지 않음을 의미하는 기본 모드입니다.
2

1 or FULL

자동 진공이 활성화되고 완전 자동으로 데이터베이스에서 데이터가 제거 될 때 데이터베이스 파일을 축소 할 수 있습니다.
삼

2 or INCREMENTAL

자동 진공이 활성화되어 있지만 수동으로 활성화해야합니다. 이 모드에서는 참조 데이터가 유지되지만 사용 가능한 페이지는 사용 가능한 목록에 추가됩니다. 이러한 페이지는incremental_vacuum pragma 언제든지.

cache_size 프라 그마

그만큼 cache_sizepragma는 메모리 내 페이지 캐시의 최대 크기를 가져 오거나 임시로 설정할 수 있습니다. 다음은 간단한 구문입니다.

PRAGMA [database.]cache_size;
PRAGMA [database.]cache_size = pages;

그만큼 pages값은 캐시의 페이지 수를 나타냅니다. 기본 제공 페이지 캐시의 기본 크기는 2,000 페이지이고 최소 크기는 10 페이지입니다.

case_sensitive_like Pragma

그만큼 case_sensitive_likepragma는 내장 LIKE 표현식의 대소 문자 구분을 제어합니다. 기본적으로이 pragma는 false이며 이는 내장 LIKE 연산자가 대소 문자를 무시 함을 의미합니다. 다음은 간단한 구문입니다.

PRAGMA case_sensitive_like = [true|false];

이 pragma의 현재 상태를 쿼리 할 방법이 없습니다.

count_changes Pragma

count_changespragma는 INSERT, UPDATE 및 DELETE와 같은 데이터 조작 문의 반환 값을 가져 오거나 설정합니다. 다음은 간단한 구문입니다.

PRAGMA count_changes;
PRAGMA count_changes = [true|false];

기본적으로이 pragma는 false이며 이러한 문은 아무 것도 반환하지 않습니다. true로 설정하면 언급 된 각 명령문은 작업의 영향을받는 행을 나타내는 단일 정수 값으로 구성된 1 열 1 행 테이블을 반환합니다.

database_list 프라 그마

그만큼 database_listpragma는 연결된 모든 데이터베이스를 나열하는 데 사용됩니다. 다음은 간단한 구문입니다.

PRAGMA database_list;

이 pragma는 데이터베이스 시퀀스 번호, 이름 및 연결된 파일을 제공하는 열려 있거나 연결된 데이터베이스 당 하나의 행이있는 3 열 테이블을 반환합니다.

Pragma 인코딩

그만큼 encodingpragma는 문자열이 데이터베이스 파일에 인코딩되고 저장되는 방식을 제어합니다. 다음은 간단한 구문입니다.

PRAGMA encoding;
PRAGMA encoding = format;

형식 값은 다음 중 하나 일 수 있습니다. UTF-8, UTF-16le, 또는 UTF-16be.

freelist_count Pragma

그만큼 freelist_countpragma는 현재 사용 가능하고 사용 가능한 것으로 표시된 데이터베이스 페이지 수를 나타내는 단일 정수를 반환합니다. 다음은 간단한 구문입니다.

PRAGMA [database.]freelist_count;

형식 값은 다음 중 하나 일 수 있습니다. UTF-8, UTF-16le, 또는 UTF-16be.

index_info 프라 그마

그만큼 index_infopragma는 데이터베이스 인덱스에 대한 정보를 반환합니다. 다음은 간단한 구문입니다.

PRAGMA [database.]index_info( index_name );

결과 세트는 열 순서, 테이블 및 열 이름이있는 열 색인을 제공하는 색인에 포함 된 각 열에 대해 하나의 행을 포함합니다.

index_list 프라 그마

index_listpragma는 테이블과 관련된 모든 인덱스를 나열합니다. 다음은 간단한 구문입니다.

PRAGMA [database.]index_list( table_name );

결과 집합에는 인덱스 시퀀스, 인덱스 이름 및 인덱스가 고유한지 여부를 나타내는 플래그를 제공하는 각 인덱스에 대해 하나의 행이 포함됩니다.

journal_mode 프라 그마

그만큼 journal_modepragma는 저널 파일이 저장되고 처리되는 방식을 제어하는 ​​저널 모드를 가져 오거나 설정합니다. 다음은 간단한 구문입니다.

PRAGMA journal_mode;
PRAGMA journal_mode = mode;
PRAGMA database.journal_mode;
PRAGMA database.journal_mode = mode;

다음 표에 나열된대로 지원되는 5 가지 저널 모드가 있습니다.

Sr. 아니. Pragma 가치 및 설명
1

DELETE

이것이 기본 모드입니다. 여기서 트랜잭션이 끝나면 저널 파일이 삭제됩니다.
2

TRUNCATE

저널 파일은 길이가 0 바이트로 잘립니다.
삼

PERSIST

저널 파일은 그대로 유지되지만 저널이 더 이상 유효하지 않음을 나타 내기 위해 헤더를 덮어 씁니다.
4

MEMORY

저널 레코드는 디스크가 아닌 메모리에 보관됩니다.
5

OFF

저널 레코드가 유지되지 않습니다.

max_page_count Pragma

그만큼 max_page_countpragma는 데이터베이스에 허용되는 최대 페이지 수를 가져 오거나 설정합니다. 다음은 간단한 구문입니다.

PRAGMA [database.]max_page_count;
PRAGMA [database.]max_page_count = max_page;

기본값은 1 기가 페이지 인 1,073,741,823입니다. 즉, 기본 페이지 크기가 1KB 인 경우 데이터베이스를 1 테라 바이트까지 늘릴 수 있습니다.

page_count Pragma

그만큼 page_countpragma는 데이터베이스의 현재 페이지 수를 반환합니다. 다음은 간단한 구문입니다-

PRAGMA [database.]page_count;

데이터베이스 파일의 크기는 page_count * page_size 여야합니다.

page_size 프라 그마

그만큼 page_sizepragma는 데이터베이스 페이지의 크기를 가져 오거나 설정합니다. 다음은 간단한 구문입니다.

PRAGMA [database.]page_size;
PRAGMA [database.]page_size = bytes;

기본적으로 허용되는 크기는 512, 1024, 2048, 4096, 8192, 16384 및 32768 바이트입니다. 기존 데이터베이스에서 페이지 크기를 변경하는 유일한 방법은 페이지 크기를 설정 한 다음 즉시 데이터베이스를 VACUUM하는 것입니다.

parser_trace 프라 그마

그만큼 parser_tracepragma는 SQL 명령을 구문 분석 할 때 디버깅 상태 인쇄를 제어합니다. 다음은 간단한 구문입니다.

PRAGMA parser_trace = [true|false];

기본적으로 false로 설정되어 있지만 true로 설정하여 활성화하면 SQL 구문 분석기는 SQL 명령을 구문 분석 할 때 상태를 인쇄합니다.

recursive_triggers Pragma

그만큼 recursive_triggerspragma는 재귀 트리거 기능을 가져 오거나 설정합니다. 재귀 트리거가 활성화되지 않은 경우 트리거 작업은 다른 트리거를 실행하지 않습니다. 다음은 간단한 구문입니다.

PRAGMA recursive_triggers;
PRAGMA recursive_triggers = [true|false];

schema_version Pragma

그만큼 schema_versionpragma는 데이터베이스 헤더에 저장된 스키마 버전 값을 가져 오거나 설정합니다. 다음은 간단한 구문입니다.

PRAGMA [database.]schema_version;
PRAGMA [database.]schema_version = number;

스키마 변경을 추적하는 32 비트 부호있는 정수 값입니다. 스키마 변경 명령 ​​(예 : CREATE ... 또는 DROP ...)이 실행될 때마다이 값이 증가합니다.

secure_delete 프라 그마

그만큼 secure_deletepragma는 데이터베이스에서 콘텐츠가 삭제되는 방식을 제어하는 ​​데 사용됩니다. 다음은 간단한 구문입니다.

PRAGMA secure_delete;
PRAGMA secure_delete = [true|false];
PRAGMA database.secure_delete;
PRAGMA database.secure_delete = [true|false];

보안 삭제 플래그의 기본값은 일반적으로 꺼져 있지만 SQLITE_SECURE_DELETE 빌드 옵션으로 변경할 수 있습니다.

sql_trace 프라 그마

그만큼 sql_tracepragma는 SQL 추적 결과를 화면에 덤프하는 데 사용됩니다. 다음은 간단한 구문입니다.

PRAGMA sql_trace;
PRAGMA sql_trace = [true|false];

이 pragma를 포함하려면 SQLite를 SQLITE_DEBUG 지시문으로 컴파일해야합니다.

동기식 Pragma

그만큼 synchronouspragma는 현재 디스크 동기화 모드를 가져 오거나 설정하여 SQLite가 물리적 저장소에 데이터를 얼마나 적극적으로 기록할지 제어합니다. 다음은 간단한 구문입니다.

PRAGMA [database.]synchronous;
PRAGMA [database.]synchronous = mode;

SQLite는 표에 나열된대로 다음 동기화 모드를 지원합니다.

Sr. 아니. Pragma 가치 및 설명
1

0 or OFF

전혀 동기화 없음
2

1 or NORMAL

중요한 디스크 작업의 각 시퀀스 후 동기화
삼

2 or FULL

각 중요한 디스크 작업 후 동기화

temp_store 프라 그마

그만큼 temp_storepragma는 임시 데이터베이스 파일에서 사용하는 저장 모드를 가져 오거나 설정합니다. 다음은 간단한 구문입니다.

PRAGMA temp_store;
PRAGMA temp_store = mode;

SQLite는 다음 저장 모드를 지원합니다.

Sr. 아니. Pragma 가치 및 설명
1

0 or DEFAULT

컴파일 타임 기본값을 사용합니다. 일반적으로 FILE.
2

1 or FILE

파일 기반 저장소를 사용합니다.
삼

2 or MEMORY

메모리 기반 저장소를 사용합니다.

temp_store_directory Pragma

그만큼 temp_store_directorypragma는 임시 데이터베이스 파일에 사용되는 위치를 가져 오거나 설정합니다. 다음은 간단한 구문입니다.

PRAGMA temp_store_directory;
PRAGMA temp_store_directory = 'directory_path';

user_version Pragma

그만큼 user_versionpragma는 데이터베이스 헤더에 저장된 사용자 정의 버전 값을 가져 오거나 설정합니다. 다음은 간단한 구문입니다.

PRAGMA [database.]user_version;
PRAGMA [database.]user_version = number;

이것은 버전 추적 목적으로 개발자가 설정할 수있는 32 비트 부호있는 정수 값입니다.

writable_schema Pragma

그만큼 writable_schemapragma는 시스템 테이블을 수정하는 기능을 가져 오거나 설정합니다. 다음은 간단한 구문입니다.

PRAGMA writable_schema;
PRAGMA writable_schema = [true|false];

이 pragma가 설정되면 sqlite_master 테이블을 포함하여 sqlite_로 시작하는 테이블을 만들고 수정할 수 있습니다. pragma를 사용하면 데이터베이스가 완전히 손상 될 수 있으므로주의하십시오.

제약 조건은 테이블의 데이터 열에 적용되는 규칙입니다. 테이블에 들어갈 수있는 데이터 유형을 제한하는 데 사용됩니다. 이것은 데이터베이스에있는 데이터의 정확성과 신뢰성을 보장합니다.

제약 조건은 열 수준 또는 테이블 수준 일 수 있습니다. 열 수준 제약 조건은 하나의 열에 만 적용되는 반면 테이블 수준 제약 조건은 전체 테이블에 적용됩니다.

다음은 SQLite에서 일반적으로 사용되는 제약 조건입니다.

  • NOT NULL Constraint − 열이 NULL 값을 가질 수 없도록합니다.

  • DEFAULT Constraint − 아무것도 지정되지 않은 경우 열에 대한 기본값을 제공합니다.

  • UNIQUE Constraint − 열의 모든 값이 다른지 확인합니다.

  • PRIMARY Key − 데이터베이스 테이블에서 각 행 / 레코드를 고유하게 식별합니다.

  • CHECK Constraint − 열의 모든 값이 특정 조건을 충족하는지 확인합니다.

NOT NULL 제약

기본적으로 열은 NULL 값을 보유 할 수 있습니다. 열이 NULL 값을 갖지 않도록하려면 해당 열에 대해 이제 NULL이 허용되지 않음을 지정하여이 열에 이러한 제약 조건을 정의해야합니다.

NULL은 데이터가없는 것과 같지 않고 알 수없는 데이터를 나타냅니다.

예

예를 들어 다음 SQLite 문은 COMPANY라는 새 테이블을 만들고 5 개의 열을 추가합니다.이 중 3 개는 ID, NAME 및 AGE가 NULL을 허용하지 않도록 지정합니다.

CREATE TABLE COMPANY(
   ID INT PRIMARY KEY     NOT NULL,
   NAME           TEXT    NOT NULL,
   AGE            INT     NOT NULL,
   ADDRESS        CHAR(50),
   SALARY         REAL
);

DEFAULT 제약

DEFAULT 제약 조건은 INSERT INTO 문이 특정 값을 제공하지 않을 때 열에 기본값을 제공합니다.

예

예를 들어 다음 SQLite 문은 COMPANY라는 새 테이블을 만들고 5 개의 열을 추가합니다. 여기서 SALARY 열은 기본적으로 5000.00으로 설정되어 있으므로 INSERT INTO 문이이 열에 대한 값을 제공하지 않는 경우 기본적으로이 열은 5000.00으로 설정됩니다.

CREATE TABLE COMPANY(
   ID INT PRIMARY KEY     NOT NULL,
   NAME           TEXT    NOT NULL,
   AGE            INT     NOT NULL,
   ADDRESS        CHAR(50),
   SALARY         REAL    DEFAULT 50000.00
);

고유 한 제약

UNIQUE 제약 조건은 두 레코드가 특정 열에서 동일한 값을 갖는 것을 방지합니다. 예를 들어 COMPANY 테이블에서 두 명 이상의 사람이 동일한 연령을 가지지 못하도록 할 수 있습니다.

예

예를 들어 다음 SQLite 문은 COMPANY라는 새 테이블을 만들고 5 개의 열을 추가합니다. 여기서 AGE 열은 UNIQUE로 설정되어 있으므로 동일한 연령의 두 레코드를 가질 수 없습니다.

CREATE TABLE COMPANY(
   ID INT PRIMARY KEY     NOT NULL,
   NAME           TEXT    NOT NULL,
   AGE            INT     NOT NULL UNIQUE,
   ADDRESS        CHAR(50),
   SALARY         REAL    DEFAULT 50000.00
);

기본 키 제약

PRIMARY KEY 제약 조건은 데이터베이스 테이블의 각 레코드를 고유하게 식별합니다. 더 많은 UNIQUE 열이있을 수 있지만 테이블에는 기본 키가 하나만 있습니다. 데이터베이스 테이블을 디자인 할 때 기본 키가 중요합니다. 기본 키는 고유 한 ID입니다.

테이블 행을 참조하는 데 사용합니다. 테이블 간의 관계를 만들 때 기본 키는 다른 테이블에서 외래 키가됩니다. '오랜 코딩 감독'으로 인해 기본 키는 SQLite에서 NULL이 될 수 있습니다. 이것은 다른 데이터베이스의 경우가 아닙니다.

기본 키는 데이터베이스 테이블의 각 행 / 레코드를 고유하게 식별하는 테이블의 필드입니다. 기본 키는 고유 한 값을 포함해야합니다. 기본 키 열은 NULL 값을 가질 수 없습니다.

테이블에는 하나 또는 여러 필드로 구성 될 수있는 하나의 기본 키만있을 수 있습니다. 여러 필드가 기본 키로 사용되는 경우이를composite key.

테이블에 필드에 정의 된 기본 키가있는 경우 해당 필드의 값이 동일한 두 개의 레코드를 가질 수 없습니다.

예

ID를 기본 키로 사용하여 COMPANY 테이블을 만든 위의 다양한 예를 이미 보았습니다.

CREATE TABLE COMPANY(
   ID INT PRIMARY KEY     NOT NULL,
   NAME           TEXT    NOT NULL,
   AGE            INT     NOT NULL,
   ADDRESS        CHAR(50),
   SALARY         REAL
);

제약 조건 확인

CHECK Constraint는 레코드에 입력되는 값을 확인하는 조건을 활성화합니다. 조건이 거짓으로 평가되면 레코드가 제약 조건을 위반하고 테이블에 입력되지 않습니다.

예

예를 들어 다음 SQLite는 COMPANY라는 새 테이블을 만들고 5 개의 열을 추가합니다. 여기에서 SALARY 열이있는 CHECK를 추가하여 SALARY 0을 가질 수 없습니다.

CREATE TABLE COMPANY3(
   ID INT PRIMARY KEY     NOT NULL,
   NAME           TEXT    NOT NULL,
   AGE            INT     NOT NULL,
   ADDRESS        CHAR(50),
   SALARY         REAL    CHECK(SALARY > 0)
);

제약 조건 삭제

SQLite는 ALTER TABLE의 제한된 하위 집합을 지원합니다. SQLite의 ALTER TABLE 명령을 사용하면 사용자가 테이블의 이름을 바꾸거나 기존 테이블에 새 열을 추가 할 수 있습니다. 열 이름을 바꾸거나 열을 제거하거나 테이블에서 제약 조건을 추가 또는 제거 할 수 없습니다.

SQLite Joins절은 데이터베이스에있는 둘 이상의 테이블에서 레코드를 결합하는 데 사용됩니다. JOIN은 각각에 공통된 값을 사용하여 두 테이블의 필드를 결합하는 수단입니다.

SQL은 세 가지 주요 유형의 조인을 정의합니다.

  • 크로스 조인
  • 내부 조인
  • 외부 조인

계속하기 전에 COMPANY 및 DEPARTMENT 테이블 두 개를 고려해 보겠습니다. COMPANY 테이블을 채우는 INSERT 문을 이미 보았습니다. 따라서 COMPANY 테이블에서 사용할 수있는 레코드 목록을 가정 해 보겠습니다.

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0

다른 테이블은 다음과 같은 정의를 가진 DEPARTMENT입니다-

CREATE TABLE DEPARTMENT(
   ID INT PRIMARY KEY      NOT NULL,
   DEPT           CHAR(50) NOT NULL,
   EMP_ID         INT      NOT NULL
);

다음은 DEPARTMENT 테이블을 채우는 INSERT 문 목록입니다.

INSERT INTO DEPARTMENT (ID, DEPT, EMP_ID)
VALUES (1, 'IT Billing', 1 );

INSERT INTO DEPARTMENT (ID, DEPT, EMP_ID)
VALUES (2, 'Engineering', 2 );

INSERT INTO DEPARTMENT (ID, DEPT, EMP_ID)
VALUES (3, 'Finance', 7 );

마지막으로, DEPARTMENT 테이블에 다음과 같은 레코드 목록이 있습니다.

ID          DEPT        EMP_ID
----------  ----------  ----------
1           IT Billing  1
2           Engineering 2
3           Finance     7

크로스 조인

CROSS JOIN은 첫 번째 테이블의 모든 행을 두 번째 테이블의 모든 행과 일치시킵니다. 입력 테이블에 각각 x 및 y 행이있는 경우 결과 테이블에는 x * y 행이 있습니다. CROSS JOIN은 매우 큰 테이블을 생성 할 수 있으므로 적절한 경우에만 사용하도록주의해야합니다.

다음은 CROSS JOIN의 구문입니다-

SELECT ... FROM table1 CROSS JOIN table2 ...

위의 표를 기반으로 다음과 같이 CROSS JOIN을 작성할 수 있습니다.

sqlite> SELECT EMP_ID, NAME, DEPT FROM COMPANY CROSS JOIN DEPARTMENT;

위의 쿼리는 다음 결과를 생성합니다-

EMP_ID      NAME        DEPT
----------  ----------  ----------
1           Paul        IT Billing
2           Paul        Engineering
7           Paul        Finance
1           Allen       IT Billing
2           Allen       Engineering
7           Allen       Finance
1           Teddy       IT Billing
2           Teddy       Engineering
7           Teddy       Finance
1           Mark        IT Billing
2           Mark        Engineering
7           Mark        Finance
1           David       IT Billing
2           David       Engineering
7           David       Finance
1           Kim         IT Billing
2           Kim         Engineering
7           Kim         Finance
1           James       IT Billing
2           James       Engineering
7           James       Finance

내부 조인

INNER JOIN은 join-predicate를 기반으로 두 테이블 (table1 및 table2)의 열 값을 결합하여 새 결과 테이블을 만듭니다. 쿼리는 table1의 각 행을 table2의 각 행과 비교하여 join-predicate를 충족하는 모든 행 쌍을 찾습니다. join-predicate가 충족되면 일치하는 A 및 B 행 쌍의 열 값이 결과 행으로 결합됩니다.

INNER JOIN은 가장 일반적인 기본 유형의 조인입니다. INNER 키워드를 선택적으로 사용할 수 있습니다.

다음은 INNER JOIN의 구문입니다-

SELECT ... FROM table1 [INNER] JOIN table2 ON conditional_expression ...

중복을 방지하고 구문을 더 짧게 유지하려면 INNER JOIN 조건을 다음과 같이 선언 할 수 있습니다. USING표현. 이 표현식은 하나 이상의 열 목록을 지정합니다.

SELECT ... FROM table1 JOIN table2 USING ( column1 ,... ) ...

NATURAL JOIN은 JOIN...USING, 그것은 자동으로 두 테이블에 존재하는 모든 열의 값 사이의 동등성을 테스트합니다-

SELECT ... FROM table1 NATURAL JOIN table2...

위의 테이블을 기반으로 다음과 같이 INNER JOIN을 작성할 수 있습니다.

sqlite> SELECT EMP_ID, NAME, DEPT FROM COMPANY INNER JOIN DEPARTMENT
   ON COMPANY.ID = DEPARTMENT.EMP_ID;

위의 쿼리는 다음 결과를 생성합니다-

EMP_ID      NAME        DEPT
----------  ----------  ----------
1           Paul        IT Billing
2           Allen       Engineering
7           James       Finance

외부 조인

OUTER JOIN은 INNER JOIN의 확장입니다. SQL 표준은 LEFT, RIGHT 및 FULL의 세 가지 유형의 OUTER JOIN을 정의하지만 SQLite는LEFT OUTER JOIN.

OUTER JOIN에는 ON, USING 또는 NATURAL 키워드를 사용하여 표현 된 INNER JOIN과 동일한 조건이 있습니다. 초기 결과 테이블은 동일한 방식으로 계산됩니다. 기본 JOIN이 계산되면 OUTER JOIN은 하나 또는 두 테이블에서 조인되지 않은 행을 가져 와서 NULL로 채운 다음 결과 테이블에 추가합니다.

다음은 LEFT OUTER JOIN의 구문입니다.

SELECT ... FROM table1 LEFT OUTER JOIN table2 ON conditional_expression ...

중복을 방지하고 구문을 더 짧게 유지하기 위해 OUTER JOIN 조건은 USING 표현식으로 선언 할 수 있습니다. 이 표현식은 하나 이상의 열 목록을 지정합니다.

SELECT ... FROM table1 LEFT OUTER JOIN table2 USING ( column1 ,... ) ...

위의 테이블을 기반으로 다음과 같이 내부 조인을 작성할 수 있습니다.

sqlite> SELECT EMP_ID, NAME, DEPT FROM COMPANY LEFT OUTER JOIN DEPARTMENT
   ON COMPANY.ID = DEPARTMENT.EMP_ID;

위의 쿼리는 다음 결과를 생성합니다-

EMP_ID      NAME        DEPT
----------  ----------  ----------
1           Paul        IT Billing
2           Allen       Engineering
            Teddy
            Mark
            David
            Kim
7           James       Finance

SQLite UNION 절 / 연산자는 중복 행을 반환하지 않고 둘 이상의 SELECT 문의 결과를 결합하는 데 사용됩니다.

UNION을 사용하려면 각 SELECT에 동일한 수의 열이 선택되고 동일한 수의 열 식과 동일한 데이터 유형이 있어야하며 동일한 순서로 있어야하지만 길이가 같을 필요는 없습니다.

통사론

다음은 기본 구문입니다. UNION.

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

UNION

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

여기서 주어진 조건은 요구 사항에 따라 주어진 표현식이 될 수 있습니다.

예

다음 두 테이블, (a) COMPANY 테이블을 다음과 같이 고려하십시오.

sqlite> select * from COMPANY;
ID          NAME                  AGE         ADDRESS     SALARY
----------  --------------------  ----------  ----------  ----------
1           Paul                  32          California  20000.0
2           Allen                 25          Texas       15000.0
3           Teddy                 23          Norway      20000.0
4           Mark                  25          Rich-Mond   65000.0
5           David                 27          Texas       85000.0
6           Kim                   22          South-Hall  45000.0
7           James                 24          Houston     10000.0

(b) 다른 테이블은 다음과 같이 DEPARTMENT입니다.

ID          DEPT                  EMP_ID
----------  --------------------  ----------
1           IT Billing            1
2           Engineering           2
3           Finance               7
4           Engineering           3
5           Finance               4
6           Engineering           5
7           Finance               6

이제 다음과 같이 UNION 절과 함께 SELECT 문을 사용하여이 두 테이블을 조인하겠습니다.

sqlite>  SELECT EMP_ID, NAME, DEPT FROM COMPANY INNER JOIN DEPARTMENT
         ON COMPANY.ID = DEPARTMENT.EMP_ID
         
         UNION
         
         SELECT EMP_ID, NAME, DEPT FROM COMPANY LEFT OUTER JOIN DEPARTMENT
         ON COMPANY.ID = DEPARTMENT.EMP_ID;

그러면 다음과 같은 결과가 생성됩니다.

EMP_ID      NAME                  DEPT
----------  --------------------  ----------
1           Paul                  IT Billing
2           Allen                 Engineering
3           Teddy                 Engineering
4           Mark                  Finance
5           David                 Engineering
6           Kim                   Finance
7           James                 Finance

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]

여기서 주어진 조건은 요구 사항에 따라 주어진 표현식이 될 수 있습니다.

예

이제 다음과 같이 SELECT 문에서 위에서 언급 한 두 테이블을 결합 해 보겠습니다.

sqlite>  SELECT EMP_ID, NAME, DEPT FROM COMPANY INNER JOIN DEPARTMENT
         ON COMPANY.ID = DEPARTMENT.EMP_ID
         
         UNION ALL

         SELECT EMP_ID, NAME, DEPT FROM COMPANY LEFT OUTER JOIN DEPARTMENT
         ON COMPANY.ID = DEPARTMENT.EMP_ID;

그러면 다음과 같은 결과가 생성됩니다.

EMP_ID      NAME                  DEPT
----------  --------------------  ----------
1           Paul                  IT Billing
2           Allen                 Engineering
3           Teddy                 Engineering
4           Mark                  Finance
5           David                 Engineering
6           Kim                   Finance
7           James                 Finance
1           Paul                  IT Billing
2           Allen                 Engineering
3           Teddy                 Engineering
4           Mark                  Finance
5           David                 Engineering
6           Kim                   Finance
7           James                 Finance

SQLite NULL결 측값을 나타내는 데 사용되는 용어입니다. 테이블의 NULL 값은 공백으로 표시되는 필드의 값입니다.

NULL 값이있는 필드는 값이없는 필드입니다. NULL 값은 0 값 또는 공백이 포함 된 필드와 다르다는 것을 이해하는 것이 매우 중요합니다.

통사론

다음은 사용의 기본 구문입니다. NULL 테이블을 만드는 동안.

SQLite> CREATE TABLE COMPANY(
   ID INT PRIMARY KEY     NOT NULL,
   NAME           TEXT    NOT NULL,
   AGE            INT     NOT NULL,
   ADDRESS        CHAR(50),
   SALARY         REAL
);

여기, NOT NULL열이 항상 주어진 데이터 유형의 명시 적 값을 허용해야 함을 나타냅니다. NOT NULL을 사용하지 않은 두 개의 열이 있는데 이는이 열이 NULL 일 수 있음을 의미합니다.

NULL 값이있는 필드는 레코드 생성 중에 비어있는 필드입니다.

예

NULL 값은 데이터를 선택할 때 문제를 일으킬 수 있습니다. 알 수없는 값을 다른 값과 비교할 때 결과는 항상 알 수없고 최종 결과에 포함되지 않기 때문입니다. 다음 레코드와 함께 다음 테이블 COMPANY 를 고려하십시오.

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0

UPDATE 문을 사용하여 다음과 같이 몇 가지 nullable 값을 NULL로 설정합니다.

sqlite> UPDATE COMPANY SET ADDRESS = NULL, SALARY = NULL where ID IN(6,7);

이제 COMPANY 테이블에는 다음 레코드가 있습니다.

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0
6           Kim         22
7           James       24

다음으로 IS NOT NULL 연산자를 사용하여 SALARY가 NULL이 아닌 모든 레코드를 나열합니다.

sqlite> SELECT  ID, NAME, AGE, ADDRESS, SALARY
        FROM COMPANY
        WHERE SALARY IS NOT NULL;

위의 SQLite 문은 다음 결과를 생성합니다-

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0

다음은 사용 IS NULL 연산자는 SALARY가 NULL 인 모든 레코드를 나열합니다.

sqlite> SELECT  ID, NAME, AGE, ADDRESS, SALARY
        FROM COMPANY
        WHERE SALARY IS NULL;

위의 SQLite 문은 다음과 같은 결과를 생성합니다.

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
6           Kim         22
7           James       24

다른 이름을 지정하여 테이블 또는 열의 이름을 임시로 바꿀 수 있습니다. ALIAS. 테이블 별칭을 사용한다는 것은 특정 SQLite 문에서 테이블 이름을 바꾸는 것을 의미합니다. 이름 변경은 일시적인 변경이며 실제 테이블 이름은 데이터베이스에서 변경되지 않습니다.

열 별칭은 특정 SQLite 쿼리를 위해 테이블의 열 이름을 바꾸는 데 사용됩니다.

통사론

다음은 기본 구문입니다. table 별명.

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

다음은 기본 구문입니다. column 별명.

SELECT column_name AS alias_name
FROM table_name
WHERE [condition];

예

다음 두 테이블을 고려하십시오. (a) COMPANY 테이블은 다음과 같습니다.

sqlite> select * from COMPANY;
ID          NAME                  AGE         ADDRESS     SALARY
----------  --------------------  ----------  ----------  ----------
1           Paul                  32          California  20000.0
2           Allen                 25          Texas       15000.0
3           Teddy                 23          Norway      20000.0
4           Mark                  25          Rich-Mond   65000.0
5           David                 27          Texas       85000.0
6           Kim                   22          South-Hall  45000.0
7           James                 24          Houston     10000.0

(b) 다른 테이블은 다음과 같이 DEPARTMENT입니다.

ID          DEPT                  EMP_ID
----------  --------------------  ----------
1           IT Billing            1
2           Engineering           2
3           Finance               7
4           Engineering           3
5           Finance               4
6           Engineering           5
7           Finance               6

이제 다음은 TABLE ALIAS 여기서 우리는 각각 COMPANY 및 DEPARTMENT 테이블의 별칭으로 C와 D를 사용합니다.

sqlite> SELECT C.ID, C.NAME, C.AGE, D.DEPT
        FROM COMPANY AS C, DEPARTMENT AS D
        WHERE  C.ID = D.EMP_ID;

위의 SQLite 문은 다음 결과를 생성합니다-

ID          NAME        AGE         DEPT
----------  ----------  ----------  ----------
1           Paul        32          IT Billing
2           Allen       25          Engineering
3           Teddy       23          Engineering
4           Mark        25          Finance
5           David       27          Engineering
6           Kim         22          Finance
7           James       24          Finance

사용 예를 고려하십시오. COLUMN ALIAS 여기서 COMPANY_ID는 ID 열의 별칭이고 COMPANY_NAME은 이름 열의 별칭입니다.

sqlite> SELECT C.ID AS COMPANY_ID, C.NAME AS COMPANY_NAME, C.AGE, D.DEPT
        FROM COMPANY AS C, DEPARTMENT AS D
        WHERE  C.ID = D.EMP_ID;

위의 SQLite 문은 다음 결과를 생성합니다-

COMPANY_ID  COMPANY_NAME  AGE         DEPT
----------  ------------  ----------  ----------
1           Paul          32          IT Billing
2           Allen         25          Engineering
3           Teddy         23          Engineering
4           Mark          25          Finance
5           David         27          Engineering
6           Kim           22          Finance
7           James         24          Finance

SQLite Triggers지정된 데이터베이스 이벤트가 발생할 때 자동으로 수행 / 호출되는 데이터베이스 콜백 함수입니다. 다음은 SQLite 트리거에 대한 중요한 사항입니다.

  • SQLite 트리거는 특정 데이터베이스 테이블의 DELETE, INSERT 또는 UPDATE가 발생할 때마다 또는 테이블의 하나 이상의 지정된 열에서 UPDATE가 발생할 때마다 실행되도록 지정할 수 있습니다.

  • 현재 SQLite는 FOR EACH STATEMENT 트리거가 아닌 FOR EACH ROW 트리거 만 지원합니다. 따라서 FOR EACH ROW를 명시 적으로 지정하는 것은 선택 사항입니다.

  • WHEN 절과 트리거 조치 모두 양식의 참조를 사용하여 삽입, 삭제 또는 업데이트되는 행의 요소에 액세스 할 수 있습니다. NEW.column-name 과 OLD.column-name여기서 column-name은 트리거가 연결된 테이블의 열 이름입니다.

  • WHEN 절이 제공되면 지정된 SQL 문은 WHEN 절이 참인 행에 대해서만 실행됩니다. WHEN 절이 제공되지 않으면 모든 행에 대해 SQL 문이 실행됩니다.

  • BEFORE 또는 AFTER 키워드는 연관된 행의 삽입, 수정 또는 제거와 관련하여 트리거 조치가 실행되는시기를 결정합니다.

  • 트리거는 연관된 테이블이 삭제되면 자동으로 삭제됩니다.

  • 수정할 테이블은 트리거가 연결된 테이블 또는 뷰와 동일한 데이터베이스에 있어야하며 tablename 아니 database.tablename.

  • 예외를 발생시키기 위해 트리거 프로그램 내에서 특수 SQL 함수 RAISE ()를 사용할 수 있습니다.

통사론

다음은 생성의 기본 구문입니다. trigger.

CREATE TRIGGER trigger_name [BEFORE|AFTER] event_name 
ON table_name
BEGIN
 -- Trigger logic goes here....
END;

여기, event_name언급 된 테이블에 대한 INSERT, DELETE 및 UPDATE 데이터베이스 작업 일 수 있습니다.table_name. 선택적으로 테이블 이름 뒤에 FOR EACH ROW를 지정할 수 있습니다.

다음은 테이블의 하나 이상의 지정된 열에서 UPDATE 작업에 대한 트리거를 만드는 구문입니다.

CREATE TRIGGER trigger_name [BEFORE|AFTER] UPDATE OF column_name 
ON table_name
BEGIN
   -- Trigger logic goes here....
END;

예

다음과 같이 새로 생성하는 COMPANY 테이블에 삽입되는 모든 레코드에 대해 감사 시도를 유지하려는 경우를 고려해 보겠습니다 (이미 가지고있는 경우 COMPANY 테이블 삭제).

sqlite> CREATE TABLE COMPANY(
   ID INT PRIMARY KEY     NOT NULL,
   NAME           TEXT    NOT NULL,
   AGE            INT     NOT NULL,
   ADDRESS        CHAR(50),
   SALARY         REAL
);

감사 시도를 계속하기 위해 새 레코드에 대한 COMPANY 테이블에 항목이있을 때마다 로그 메시지가 삽입되는 AUDIT라는 새 테이블을 만듭니다.

sqlite> CREATE TABLE AUDIT(
   EMP_ID INT NOT NULL,
   ENTRY_DATE TEXT NOT NULL
);

여기서 ID는 AUDIT 레코드 ID이고 EMP_ID는 COMPANY 테이블에서 가져올 ID이며 DATE는 레코드가 COMPANY 테이블에 생성 될 때 타임 스탬프를 유지합니다. 이제 다음과 같이 COMPANY 테이블에 트리거를 생성 해 보겠습니다.

sqlite> CREATE TRIGGER audit_log AFTER INSERT 
ON COMPANY
BEGIN
   INSERT INTO AUDIT(EMP_ID, ENTRY_DATE) VALUES (new.ID, datetime('now'));
END;

이제 실제 작업을 시작하겠습니다. COMPANY 테이블에 레코드 삽입을 시작합니다. 그러면 AUDIT 테이블에 감사 로그 레코드가 생성됩니다. 다음과 같이 COMPANY 테이블에 하나의 레코드를 만듭니다.

sqlite> INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY)
VALUES (1, 'Paul', 32, 'California', 20000.00 );

이렇게하면 COMPANY 테이블에 다음과 같은 하나의 레코드가 생성됩니다.

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0

동시에 AUDIT 테이블에 하나의 레코드가 생성됩니다. 이 레코드는 COMPANY 테이블의 INSERT 연산에서 생성 한 트리거의 결과입니다. 마찬가지로 요구 사항에 따라 UPDATE 및 DELETE 작업에 대한 트리거를 만들 수 있습니다.

EMP_ID      ENTRY_DATE
----------  -------------------
1           2013-04-05 06:26:00

트리거 나열

모든 트리거를 나열 할 수 있습니다. sqlite_master 다음과 같이 표-

sqlite> SELECT name FROM sqlite_master
WHERE type = 'trigger';

위의 SQLite 문은 다음과 같이 하나의 항목 만 나열합니다.

name
----------
audit_log

특정 테이블에 대한 트리거를 나열하려면 다음과 같이 테이블 이름과 함께 AND 절을 사용하십시오.

sqlite> SELECT name FROM sqlite_master
WHERE type = 'trigger' AND tbl_name = 'COMPANY';

위의 SQLite 문은 다음과 같이 하나의 항목 만 나열합니다.

name
----------
audit_log

트리거 삭제

다음은 기존 트리거를 삭제하는 데 사용할 수있는 DROP 명령입니다.

sqlite> DROP TRIGGER trigger_name;

인덱스는 데이터베이스 검색 엔진이 데이터 검색 속도를 높이는 데 사용할 수있는 특수 조회 테이블입니다. 간단히 말해서index테이블의 데이터에 대한 포인터입니다. 데이터베이스의 색인은 책 뒷면의 색인과 매우 유사합니다.

예를 들어, 특정 주제에 대해 논의하는 책의 모든 페이지를 참조하려면 먼저 색인을 참조하십시오. 색인은 모든 주제를 알파벳순으로 나열한 다음 하나 이상의 특정 페이지 번호를 참조합니다.

인덱스는 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 절에서 필터로 자주 사용되는 열이 두 개 이상있는 경우 복합 인덱스가 최선의 선택입니다.

암시 적 인덱스

암시 적 인덱스는 개체가 생성 될 때 데이터베이스 서버에서 자동으로 생성되는 인덱스입니다. 기본 키 제약 조건 및 고유 제약 조건에 대해 인덱스가 자동으로 생성됩니다.

Example

다음은 급여 열에 대한 COMPANY 테이블에 인덱스를 생성하는 예입니다.

sqlite> CREATE INDEX salary_index ON COMPANY (salary);

이제 다음을 사용하여 COMPANY 테이블에서 사용할 수있는 모든 인덱스를 나열하겠습니다. .indices 다음과 같이 명령-

sqlite> .indices COMPANY

그러면 다음 결과가 생성됩니다. 여기서 sqlite_autoindex_COMPANY_1 은 테이블 자체가 생성 될 때 생성 된 암시 적 인덱스입니다.

salary_index
sqlite_autoindex_COMPANY_1

다음과 같이 모든 인덱스 데이터베이스를 나열 할 수 있습니다.

sqlite> SELECT * FROM sqlite_master WHERE type = 'index';

DROP INDEX 명령

SQLite를 사용하여 인덱스를 삭제할 수 있습니다. DROP명령. 성능이 느려지거나 향상 될 수 있으므로 인덱스를 삭제할 때주의해야합니다.

다음은 기본 구문은 다음과 같습니다-

DROP INDEX index_name;

다음 문을 사용하여 이전에 만든 인덱스를 삭제할 수 있습니다.

sqlite> DROP INDEX salary_index;

인덱스는 언제 피해야합니까?

인덱스는 데이터베이스의 성능을 향상시키기위한 것이지만 피해야하는 경우가 있습니다. 다음 지침은 인덱스 사용을 재고해야하는시기를 나타냅니다.

인덱스는-

  • 작은 테이블.
  • 빈번한 대규모 일괄 업데이트 또는 삽입 작업이있는 테이블.
  • 많은 수의 NULL 값을 포함하는 열입니다.
  • 자주 조작되는 열입니다.

"INDEXED BY index-name"절은 이전 테이블에서 값을 조회하기 위해 명명 된 인덱스를 사용해야 함을 지정합니다.

index-name이 존재하지 않거나 쿼리에 사용할 수없는 경우 SQLite 문의 준비가 실패합니다.

"NOT INDEXED"절은 UNIQUE 및 PRIMARY KEY 제약 조건에 의해 생성 된 암시 적 인덱스를 포함하여 앞의 테이블에 액세스 할 때 인덱스가 사용되지 않도록 지정합니다.

그러나 "NOT INDEXED"가 지정된 경우에도 INTEGER PRIMARY KEY를 사용하여 항목을 조회 할 수 있습니다.

통사론

다음은 INDEXED BY 절에 대한 구문이며 DELETE, UPDATE 또는 SELECT 문과 함께 사용할 수 있습니다.

SELECT|DELETE|UPDATE column1, column2...
INDEXED BY (index_name)
table_name
WHERE (CONDITION);

예

COMPANY 테이블을 고려하십시오 . 인덱스를 생성하여 INDEXED BY 연산을 수행하는 데 사용합니다.

sqlite> CREATE INDEX salary_index ON COMPANY(salary);
sqlite>

이제 테이블 COMPANY에서 데이터를 선택하면 다음과 같이 INDEXED BY 절을 사용할 수 있습니다.

sqlite> SELECT * FROM COMPANY INDEXED BY salary_index WHERE salary > 5000;

그러면 다음과 같은 결과가 생성됩니다.

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
7           James       24          Houston     10000.0
2           Allen       25          Texas       15000.0
1           Paul        32          California  20000.0
3           Teddy       23          Norway      20000.0
6           Kim         22          South-Hall  45000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0

SQLite ALTER TABLE명령은 전체 덤프를 수행하지 않고 데이터를 다시로드하지 않고 기존 테이블을 수정합니다. ALTER TABLE 문을 사용하여 테이블의 이름을 바꿀 수 있으며 ALTER TABLE 문을 사용하여 기존 테이블에 추가 열을 추가 할 수 있습니다.

테이블 이름을 변경하고 기존 테이블에 열을 추가하는 것 외에는 SQLite에서 ALTER TABLE 명령이 지원하는 다른 작업이 없습니다.

통사론

다음은 기본 구문입니다. ALTER TABLE 기존 테이블의 이름을 변경합니다.

ALTER TABLE database_name.table_name RENAME TO new_table_name;

다음은 기본 구문입니다. ALTER TABLE 기존 테이블에 새 열을 추가합니다.

ALTER TABLE database_name.table_name ADD COLUMN column_def...;

예

다음 레코드가 있는 COMPANY 테이블을 고려하십시오.

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0

이제 다음과 같이 ALTER TABLE 문을 사용하여이 테이블의 이름을 변경해 보겠습니다.

sqlite> ALTER TABLE COMPANY RENAME TO OLD_COMPANY;

위의 SQLite 문은 COMPANY 테이블의 이름을 OLD_COMPANY로 변경합니다. 이제 다음과 같이 OLD_COMPANY 테이블에 새 열을 추가해 보겠습니다.

sqlite> ALTER TABLE OLD_COMPANY ADD COLUMN SEX char(1);

이제 COMPANY 테이블이 변경되었으며 다음은 SELECT 문의 출력입니다.

ID          NAME        AGE         ADDRESS     SALARY      SEX
----------  ----------  ----------  ----------  ----------  ---
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0

새로 추가 된 컬럼은 NULL 값으로 채워집니다.

불행히도 SQLite에는 TRUNCATE TABLE 명령이 없지만 SQLite를 사용할 수 있습니다. DELETE 명령을 사용하여 기존 테이블에서 전체 데이터를 삭제하지만 DROP TABLE 명령을 사용하여 전체 테이블을 삭제하고 다시 생성하는 것이 좋습니다.

통사론

다음은 DELETE 명령의 기본 구문입니다.

sqlite> DELETE FROM table_name;

다음은 DROP TABLE의 기본 구문입니다.

sqlite> DROP TABLE table_name;

DELETE TABLE 명령을 사용하여 모든 레코드를 삭제하는 경우 사용하는 것이 좋습니다. VACUUM 사용하지 않는 공간을 지우는 명령.

예

다음 레코드가있는 COMPANY 테이블을 고려하십시오 .

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0

다음은 위의 표를 자르는 예입니다.

SQLite> DELETE FROM COMPANY;
SQLite> VACUUM;

이제 COMPANY 테이블이 완전히 잘리고 SELECT 문의 출력이되지 않습니다.

뷰는 연결된 이름으로 데이터베이스에 저장되는 SQLite 문에 불과합니다. 실제로 미리 정의 된 SQLite 쿼리 형식의 테이블 구성입니다.

뷰에는 테이블의 모든 행 또는 하나 이상의 테이블에서 선택한 행이 포함될 수 있습니다. 뷰를 생성하기 위해 작성된 SQLite 쿼리에 의존하는 하나 이상의 테이블에서 뷰를 생성 할 수 있습니다.

가상 테이블의 종류 인 뷰는 사용자가-

  • 사용자 또는 사용자 클래스가 자연 스럽거나 직관적 인 방식으로 데이터를 구조화합니다.

  • 사용자가 전체 테이블 대신 제한된 데이터 만 볼 수 있도록 데이터에 대한 액세스를 제한합니다.

  • 보고서를 생성하는 데 사용할 수있는 다양한 테이블의 데이터를 요약합니다.

SQLite 뷰는 읽기 전용이므로 뷰에서 DELETE, INSERT 또는 UPDATE 문을 실행할 수 없습니다. 그러나 뷰를 DELETE, INSERT 또는 UPDATE하려는 시도에서 발생하는 트리거를 뷰에 생성하고 트리거 본문에서 필요한 작업을 수행 할 수 있습니다.

보기 만들기

SQLite 뷰는 CREATE VIEW성명서. SQLite 뷰는 단일 테이블, 여러 테이블 또는 다른 뷰에서 만들 수 있습니다.

다음은 기본 CREATE VIEW 구문입니다.

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

일반 SQL SELECT 쿼리에서 사용하는 것과 유사한 방식으로 SELECT 문에 여러 테이블을 포함 할 수 있습니다. 선택적 TEMP 또는 TEMPORARY 키워드가있는 경우 임시 데이터베이스에 뷰가 생성됩니다.

예

다음 레코드가있는 COMPANY 테이블을 고려하십시오.

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0

다음은 COMPANY 테이블에서 뷰를 생성하는 예입니다. 이 뷰는 COMPANY 테이블의 열이 몇 개만있는 데 사용됩니다.

sqlite> CREATE VIEW COMPANY_VIEW AS
SELECT ID, NAME, AGE
FROM  COMPANY;

이제 실제 테이블을 쿼리하는 것과 비슷한 방식으로 COMPANY_VIEW를 쿼리 할 수 ​​있습니다. 다음은 예입니다-

sqlite> SELECT * FROM COMPANY_VIEW;

그러면 다음과 같은 결과가 생성됩니다.

ID          NAME        AGE
----------  ----------  ----------
1           Paul        32
2           Allen       25
3           Teddy       23
4           Mark        25
5           David       27
6           Kim         22
7           James       24

뷰 삭제

뷰를 삭제하려면 DROP VIEW 문을 view_name. 기본 DROP VIEW 구문은 다음과 같습니다.

sqlite> DROP VIEW view_name;

다음 명령은 마지막 섹션에서 만든 COMPANY_VIEW 뷰를 삭제합니다.

sqlite> DROP VIEW COMPANY_VIEW;

트랜잭션은 데이터베이스에 대해 수행되는 작업 단위입니다. 트랜잭션은 사용자가 수동으로 수행하든 또는 일종의 데이터베이스 프로그램에 의해 자동으로 수행 되든 논리적 순서로 수행되는 작업 단위 또는 시퀀스입니다.

트랜잭션은 데이터베이스에 대한 하나 이상의 변경 사항을 전파하는 것입니다. 예를 들어 테이블에서 레코드를 생성, 업데이트 또는 삭제하는 경우 테이블에서 트랜잭션을 수행하는 것입니다. 데이터 무결성을 보장하고 데이터베이스 오류를 처리하기 위해 트랜잭션을 제어하는 ​​것이 중요합니다.

실제로 많은 SQLite 쿼리를 그룹으로 묶고 트랜잭션의 일부로 모두 함께 실행합니다.

거래의 속성

트랜잭션에는 일반적으로 약어 ACID로 참조되는 다음 네 가지 표준 속성이 있습니다.

  • Atomicity− 작업 단위 내의 모든 작업이 성공적으로 완료되었는지 확인합니다. 그렇지 않으면 트랜잭션이 실패 지점에서 중단되고 이전 작업이 이전 상태로 롤백됩니다.

  • Consistency − 성공적으로 커밋 된 트랜잭션에서 데이터베이스가 상태를 적절하게 변경하는지 확인합니다.

  • Isolation − 트랜잭션이 서로 독립적이고 투명하게 작동 할 수 있습니다.

  • Durability − 시스템 장애시 커밋 된 트랜잭션의 결과 또는 효과가 지속되도록합니다.

거래 통제

다음은 트랜잭션을 제어하는 ​​데 사용되는 다음 명령입니다.

  • BEGIN TRANSACTION − 거래를 시작합니다.

  • COMMIT − 변경 사항을 저장하려면 다음을 사용할 수 있습니다. END TRANSACTION 명령.

  • ROLLBACK − 변경 사항을 롤백합니다.

트랜잭션 제어 명령은 DML 명령 INSERT, UPDATE 및 DELETE에만 사용됩니다. 이러한 작업은 데이터베이스에서 자동으로 커밋되기 때문에 테이블을 생성하거나 삭제하는 동안에는 사용할 수 없습니다.

BEGIN TRANSACTION 명령

트랜잭션은 BEGIN TRANSACTION 또는 단순히 BEGIN 명령을 사용하여 시작할 수 있습니다. 이러한 트랜잭션은 일반적으로 다음 COMMIT 또는 ROLLBACK 명령이 발생할 때까지 지속됩니다. 그러나 데이터베이스가 닫히거나 오류가 발생하면 트랜잭션도 ROLLBACK됩니다. 다음은 트랜잭션을 시작하는 간단한 구문입니다.

BEGIN;
or 
BEGIN TRANSACTION;

COMMIT 명령

COMMIT 명령은 트랜잭션에 의해 호출 된 변경 사항을 데이터베이스에 저장하는 데 사용되는 트랜잭션 명령입니다.

COMMIT 명령은 마지막 COMMIT 또는 ROLLBACK 명령 이후 모든 트랜잭션을 데이터베이스에 저장합니다.

다음은 COMMIT 명령 구문입니다.

COMMIT;
or
END TRANSACTION;

ROLLBACK 명령

ROLLBACK 명령은 데이터베이스에 아직 저장되지 않은 트랜잭션을 실행 취소하는 데 사용되는 트랜잭션 명령입니다.

ROLLBACK 명령은 마지막 COMMIT 또는 ROLLBACK 명령이 발행 된 이후 트랜잭션을 실행 취소하는 데만 사용할 수 있습니다.

다음은 ROLLBACK 명령 구문입니다.

ROLLBACK;

Example

다음 레코드가있는 COMPANY 테이블을 고려하십시오 .

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0

이제 트랜잭션을 시작하고 age = 25 인 테이블에서 레코드를 삭제합니다. 그런 다음 ROLLBACK 명령을 사용하여 모든 변경 사항을 취소합니다.

sqlite> BEGIN;
sqlite> DELETE FROM COMPANY WHERE AGE = 25;
sqlite> ROLLBACK;

이제 COMPANY 테이블을 확인하면 다음과 같은 레코드가 있습니다.

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0

다른 트랜잭션을 시작하고 age = 25 인 테이블에서 레코드를 삭제하고 마지막으로 COMMIT 명령을 사용하여 모든 변경 사항을 커밋합니다.

sqlite> BEGIN;
sqlite> DELETE FROM COMPANY WHERE AGE = 25;
sqlite> COMMIT;

이제 COMPANY 테이블을 확인하면 여전히 다음 레코드가 있습니다.

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
3           Teddy       23          Norway      20000.0
5           David       27          Texas       85000.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0

하위 쿼리 또는 내부 쿼리 또는 중첩 쿼리는 다른 SQLite 쿼리 내의 쿼리이며 WHERE 절에 포함됩니다.

하위 쿼리는 검색 할 데이터를 추가로 제한하는 조건으로 기본 쿼리에서 사용될 데이터를 반환하는 데 사용됩니다.

하위 쿼리는 =, <,>,> =, <=, IN, BETWEEN 등과 같은 연산자와 함께 SELECT, INSERT, UPDATE 및 DELETE 문과 함께 사용할 수 있습니다.

하위 쿼리가 따라야하는 몇 가지 규칙이 있습니다.

  • 하위 쿼리는 괄호로 묶어야합니다.

  • 하위 쿼리가 선택한 열을 비교하기위한 기본 쿼리에 여러 열이있는 경우가 아니면 하위 쿼리는 SELECT 절에 하나의 열만 가질 수 있습니다.

  • 주 쿼리는 ORDER BY를 사용할 수 있지만 ORDER BY는 하위 쿼리에서 사용할 수 없습니다. GROUP BY는 하위 쿼리의 ORDER BY와 동일한 기능을 수행하는 데 사용할 수 있습니다.

  • 둘 이상의 행을 반환하는 하위 쿼리는 IN 연산자와 같은 여러 값 연산자와 함께 만 사용할 수 있습니다.

  • 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])

예

다음 레코드가있는 COMPANY 테이블을 고려하십시오 .

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0

이제 SELECT 문을 사용하여 다음 하위 쿼리를 확인하겠습니다.

sqlite> SELECT * 
   FROM COMPANY 
   WHERE ID IN (SELECT ID 
      FROM COMPANY 
      WHERE SALARY > 45000) ;

그러면 다음과 같은 결과가 생성됩니다.

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0

INSERT 문이있는 하위 쿼리

INSERT 문과 함께 하위 쿼리를 사용할 수도 있습니다. INSERT 문은 하위 쿼리에서 반환 된 데이터를 사용하여 다른 테이블에 삽입합니다. 하위 쿼리에서 선택한 데이터는 문자, 날짜 또는 숫자 함수로 수정할 수 있습니다.

다음은 기본 구문은 다음과 같습니다-

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

예

COMPANY 테이블과 구조가 유사한 COMPANY_BKP 테이블을 고려하고 COMPANY_BKP를 테이블 이름으로 사용하여 동일한 CREATE TABLE을 사용하여 생성 할 수 있습니다. 완전한 COMPANY 테이블을 COMPANY_BKP에 복사하려면 다음 구문은 다음과 같습니다.

sqlite> INSERT INTO COMPANY_BKP
   SELECT * FROM COMPANY 
   WHERE ID IN (SELECT ID 
      FROM COMPANY) ;

UPDATE 문이있는 하위 쿼리

하위 쿼리는 UPDATE 문과 함께 사용할 수 있습니다. UPDATE 문과 함께 하위 쿼리를 사용할 때 테이블의 단일 또는 여러 열을 업데이트 할 수 있습니다.

다음은 기본 구문은 다음과 같습니다-

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

예

COMPANY 테이블의 백업 인 COMPANY_BKP 테이블을 사용할 수 있다고 가정합니다.

다음 예는 AGE가 27보다 크거나 같은 모든 고객에 대해 COMPANY 테이블에서 SALARY를 0.50 배 업데이트합니다.

sqlite> UPDATE COMPANY
   SET SALARY = SALARY * 0.50
   WHERE AGE IN (SELECT AGE FROM COMPANY_BKP
      WHERE AGE >= 27 );

이것은 두 행에 영향을 미치고 마지막으로 COMPANY 테이블에는 다음과 같은 레코드가 있습니다.

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  10000.0
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       42500.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0

DELETE 문이있는 하위 쿼리

하위 쿼리는 위에서 언급 한 다른 문과 마찬가지로 DELETE 문과 함께 사용할 수 있습니다.

다음은 기본 구문은 다음과 같습니다-

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

예

COMPANY 테이블의 백업 인 COMPANY_BKP 테이블을 사용할 수 있다고 가정합니다.

다음 예는 AGE가 27 이상인 모든 고객에 대한 COMPANY 테이블에서 레코드를 삭제합니다.

sqlite> DELETE FROM COMPANY
   WHERE AGE IN (SELECT AGE FROM COMPANY_BKP
   WHERE AGE > 27 );

이것은 두 행에 영향을 미치고 마지막으로 COMPANY 테이블은 다음 레코드를 갖게됩니다.

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       42500.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0

SQLite AUTOINCREMENT테이블의 필드 값을 자동으로 증가시키는 데 사용되는 키워드입니다. 다음을 사용하여 필드 값을 자동으로 증가시킬 수 있습니다.AUTOINCREMENT 특정 열 이름으로 테이블을 생성 할 때 키워드를 자동으로 증가시킵니다.

키워드 AUTOINCREMENT INTEGER 필드에서만 사용할 수 있습니다.

통사론

기본 사용법 AUTOINCREMENT 키워드는 다음과 같습니다-

CREATE TABLE table_name(
   column1 INTEGER AUTOINCREMENT,
   column2 datatype,
   column3 datatype,
   .....
   columnN datatype,
);

예

다음과 같이 생성되는 COMPANY 테이블을 고려하십시오-

sqlite> CREATE TABLE COMPANY(
   ID INTEGER PRIMARY KEY AUTOINCREMENT,
   NAME           TEXT      NOT NULL,
   AGE            INT       NOT NULL,
   ADDRESS        CHAR(50),
   SALARY         REAL
);

이제 다음 레코드를 COMPANY 테이블에 삽입하십시오.

INSERT INTO COMPANY (NAME,AGE,ADDRESS,SALARY)
VALUES ( 'Paul', 32, 'California', 20000.00 );

INSERT INTO COMPANY (NAME,AGE,ADDRESS,SALARY)
VALUES ('Allen', 25, 'Texas', 15000.00 );

INSERT INTO COMPANY (NAME,AGE,ADDRESS,SALARY)
VALUES ('Teddy', 23, 'Norway', 20000.00 );

INSERT INTO COMPANY (NAME,AGE,ADDRESS,SALARY)
VALUES ( 'Mark', 25, 'Rich-Mond ', 65000.00 );

INSERT INTO COMPANY (NAME,AGE,ADDRESS,SALARY)
VALUES ( 'David', 27, 'Texas', 85000.00 );

INSERT INTO COMPANY (NAME,AGE,ADDRESS,SALARY)
VALUES ( 'Kim', 22, 'South-Hall', 45000.00 );

INSERT INTO COMPANY (NAME,AGE,ADDRESS,SALARY)
VALUES ( 'James', 24, 'Houston', 10000.00 );

이렇게하면 COMPANY 테이블에 7 개의 튜플이 삽입되고 COMPANY는 다음과 같은 레코드를 갖게됩니다.

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0

웹 페이지를 통해 사용자 입력을 가져와 SQLite 데이터베이스에 삽입하면 SQL 주입으로 알려진 보안 문제로 인해 자신을 활짝 열어 놓을 가능성이 있습니다. 이 장에서는 이러한 일이 발생하지 않도록하는 방법과 스크립트 및 SQLite 문을 보호하는 방법을 배우게됩니다.

주입은 일반적으로 사용자에게 이름과 같은 입력을 요청할 때 발생하며 이름 대신 데이터베이스에서 무의식적으로 실행할 SQLite 문을 제공합니다.

사용자가 제공 한 데이터를 신뢰하지 말고 유효성 검사 후에 만이 데이터를 처리하십시오. 일반적으로 이것은 패턴 일치에 의해 수행됩니다. 다음 예에서 사용자 이름은 영숫자 문자와 밑줄 및 8 자에서 20 자 사이의 길이로 제한됩니다. 필요에 따라 이러한 규칙을 수정하십시오.

if (preg_match("/^\w{8,20}$/", $_GET['username'], $matches)){ $db = new SQLiteDatabase('filename');
   $result = @$db->query("SELECT * FROM users WHERE username = $matches[0]");
} else {
   echo "username not accepted";
}

문제를 설명하기 위해이 발췌를 고려하십시오.

$name = "Qadir'; DELETE FROM users;";
@$db->query("SELECT * FROM users WHERE username = '{$name}'");

함수 호출은 이름 열이 사용자가 지정한 이름과 일치하는 사용자 테이블에서 레코드를 검색해야합니다. 정상적인 상황에서$name영숫자 문자와 ilia 문자열과 같은 공백 만 포함합니다. 그러나이 경우 $ name에 완전히 새로운 쿼리를 추가하면 데이터베이스 호출이 재앙으로 바뀝니다. 삽입 된 DELETE 쿼리는 사용자의 모든 레코드를 제거합니다.

단일 함수 호출에서 쿼리 스택 또는 여러 쿼리 실행을 허용하지 않는 데이터베이스 인터페이스가 있습니다. 쿼리를 스택하려고하면 호출이 실패하지만 SQLite와 PostgreSQL은 스택 쿼리를 즐겁게 수행하고 하나의 문자열로 제공된 모든 쿼리를 실행하고 심각한 보안 문제를 만듭니다.

SQL 주입 방지

PERL 및 PHP와 같은 스크립팅 언어에서 모든 이스케이프 문자를 현명하게 처리 할 수 ​​있습니다. 프로그래밍 언어 PHP가 제공하는 기능string sqlite_escape_string() SQLite에 특수한 입력 문자를 이스케이프합니다.

if (get_magic_quotes_gpc()) {
   $name = sqlite_escape_string($name);
}
$result = @$db->query("SELECT * FROM users WHERE username = '{$name}'");

인코딩으로 인해 데이터를 안전하게 삽입 할 수 있지만 간단한 텍스트 비교 및 LIKE 이진 데이터가 포함 된 열에 대해 쿼리의 절을 사용할 수 없습니다.

Note − addslashes()SQLite 쿼리에 대한 문자열을 인용하는 데 사용해서는 안됩니다. 데이터를 검색 할 때 이상한 결과를 초래합니다.

SQLite 문 앞에는 키워드 "EXPLAIN"이나 테이블 세부 사항을 설명하는 데 사용되는 "EXPLAIN QUERY PLAN"구문이 올 수 있습니다.

수정하면 SQLite 문이 쿼리로 작동하고 EXPLAIN 키워드 또는 구문이 생략 된 경우 SQLite 문이 어떻게 작동했을지에 대한 정보를 반환합니다.

  • EXPLAIN 및 EXPLAIN QUERY PLAN의 출력은 대화 형 분석 및 문제 해결 전용입니다.

  • 출력 형식의 세부 사항은 SQLite의 한 릴리스에서 다음 릴리스로 변경 될 수 있습니다.

  • 애플리케이션의 정확한 동작은 가변적이고 부분적으로 만 문서화되므로 EXPLAIN 또는 EXPLAIN QUERY PLAN을 사용해서는 안됩니다.

통사론

구문 EXPLAIN 다음과 같습니다-

EXPLAIN [SQLite Query]

구문 EXPLAIN QUERY PLAN 다음과 같습니다-

EXPLAIN  QUERY PLAN [SQLite Query]

예

다음 레코드가있는 COMPANY 테이블을 고려하십시오.

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0

이제 SELECT 문으로 다음 하위 쿼리를 확인합니다.

sqlite> EXPLAIN SELECT * FROM COMPANY WHERE Salary >= 20000;

그러면 다음과 같은 결과가 생성됩니다.

addr        opcode      p1          p2          p3
----------  ----------  ----------  ----------  ----------
0           Goto        0           19
1           Integer     0           0
2           OpenRead    0           8
3           SetNumColu  0           5
4           Rewind      0           17
5           Column      0           4
6           RealAffini  0           0
7           Integer     20000       0
8           Lt          357         16          collseq(BI
9           Rowid       0           0
10          Column      0           1
11          Column      0           2
12          Column      0           3
13          Column      0           4
14          RealAffini  0           0
15          Callback    5           0
16          Next        0           5
17          Close       0           0
18          Halt        0           0
19          Transactio  0           0
20          VerifyCook  0           38
21          Goto        0           1
22          Noop        0           0

이제 다음을 확인하겠습니다. Explain Query Plan SELECT 문 사용-

SQLite> EXPLAIN QUERY PLAN SELECT * FROM COMPANY WHERE Salary >= 20000;

order       from        detail
----------  ----------  -------------
0           0           TABLE COMPANY

VACUUM 명령은 내용을 임시 데이터베이스 파일에 복사하고 복사본에서 원본 데이터베이스 파일을 다시로드하여 기본 데이터베이스를 정리합니다. 이렇게하면 사용 가능한 페이지가 제거되고 테이블 데이터가 연속적으로 정렬되며 그렇지 않으면 데이터베이스 파일 구조가 정리됩니다.

VACUUM 명령은 명시 적 INTEGER PRIMARY KEY가없는 테이블 항목의 ROWID를 변경할 수 있습니다. VACUUM 명령은 주 데이터베이스에서만 작동합니다. 첨부 된 데이터베이스 파일을 VACUUM 할 수 없습니다.

활성 트랜잭션이 있으면 VACUUM 명령이 실패합니다. VACUUM 명령은 메모리 내 데이터베이스에 대해 작동하지 않습니다. VACUUM 명령은 데이터베이스 파일을 처음부터 다시 빌드하므로 VACUUM을 사용하여 많은 데이터베이스 별 구성 매개 변수를 수정할 수도 있습니다.

수동 진공

다음은 명령 프롬프트에서 전체 데이터베이스에 대해 VACUUM 명령을 실행하는 간단한 구문입니다.

$sqlite3 database_name "VACUUM;"

다음과 같이 SQLite 프롬프트에서 VACUUM을 실행할 수 있습니다.

sqlite> VACUUM;

다음과 같이 특정 테이블에서 VACUUM을 실행할 수도 있습니다.

sqlite> VACUUM table_name;

자동 진공

SQLite Auto-VACUUM은 VACUUM과 동일하지 않고 사용 가능한 페이지를 데이터베이스 끝으로 이동하여 데이터베이스 크기를 줄입니다. 이렇게하면 VACUUM이 조각 모음을 보장하는 동안 데이터베이스를 크게 조각화 할 수 있습니다. 따라서 Auto-VACUUM은 데이터베이스를 작게 유지합니다.

SQLite 프롬프트에서 실행되는 다음 pragma로 SQLite 자동 청소를 활성화 / 비활성화 할 수 있습니다.

sqlite> PRAGMA auto_vacuum = NONE; -- 0 means disable auto vacuum
sqlite> PRAGMA auto_vacuum = FULL; -- 1 means enable full auto vacuum
sqlite> PRAGMA auto_vacuum = INCREMENTAL; -- 2 means enable incremental vacuum

명령 프롬프트에서 다음 명령을 실행하여 자동 진공 설정을 확인할 수 있습니다.

$sqlite3 database_name "PRAGMA auto_vacuum;"

SQLite는 다음과 같이 5 개의 날짜 및 시간 기능을 지원합니다.

Sr. 아니. 함수 예
1 날짜 (시간 문자열, 수정 자 ...) 다음 형식으로 날짜를 반환합니다. YYYY-MM-DD
2 시간 (시간 문자열, 수정 자 ...) 시간을 HH : MM : SS로 반환합니다.
삼 datetime (시간 문자열, 수정 자 ...) YYYY-MM-DD HH : MM : SS를 반환합니다.
4 julianday (시간 문자열, 수정 자 ...) BC 4714 년 11 월 24 일 그리니치 정오 이후의 일 수를 반환합니다.
5 strftime (시간 문자열, 수정 자 ...) 아래에 설명 된 포맷터에 따라 포맷 된 첫 번째 인수로 지정된 포맷 문자열에 따라 포맷 된 날짜를 반환합니다.

위의 다섯 가지 날짜 및 시간 함수는 모두 시간 문자열을 인수로 사용합니다. 시간 문자열 다음에는 0 개 이상의 수정자가옵니다. strftime () 함수는 또한 첫 번째 인수로 형식 문자열을 사용합니다. 다음 섹션에서는 다양한 유형의 시간 문자열 및 수정 자에 대해 자세히 설명합니다.

시간 문자열

시간 문자열은 다음 형식 중 하나 일 수 있습니다.

Sr. 아니. 시간 문자열 예
1 YYYY-MM-DD 2010-12-30
2 YYYY-MM-DD HH : MM 2010-12-30 12:10
삼 YYYY-MM-DD HH : MM : SS.SSS 2010-12-30 12 : 10 : 04.100
4 MM-DD-YYYY HH : MM 2010 년 12 월 30 일 12:10
5 HH : MM 12:10
6 YYYY-MM-DDTHH : MM 2010-12-30 12:10
7 HH : MM : SS 12:10:01
8 YYYYMMDD HHMMSS 20101230 121001
9 지금 2013-05-07

"T"는 날짜와 시간을 구분하는 리터럴 문자로 사용할 수 있습니다.

수정 자

시간 문자열 뒤에는 위의 5 개 함수 중 하나에 의해 반환 된 날짜 및 / 또는 시간을 변경하는 0 개 이상의 수정자가 올 수 있습니다. 수정자는 왼쪽에서 오른쪽으로 적용됩니다.

다음 수정자는 SQLite에서 사용할 수 있습니다-

  • NNN 일
  • NNN 시간
  • NNN 분
  • NNN.NNNN 초
  • NNN 개월
  • NNN 년
  • 월초
  • 연초
  • 하루의 시작
  • 평일 N
  • unixepoch
  • localtime
  • utc

포맷터

SQLite는 매우 편리한 기능을 제공합니다 strftime()날짜와 시간을 포맷합니다. 다음 대체를 사용하여 날짜 및 시간을 형식화 할 수 있습니다.

치환 기술
%디 날짜, 01-31
%에프 밀리 초, SS.SSS
% H 시간, 00-23
%제이 일, 001-366
%제이 율리우스 력 일 번호, DDDD.DDDD
%미디엄 월, 00-12
%미디엄 분, 00-59
%에스 1970-01-01 이후 초
%에스 초, 00-59
% w 요일, 0-6 (0은 일요일)
% W 연중 주, 01-53
%와이 연도, YYYY
%% % 기호

예

이제 SQLite 프롬프트를 사용하여 다양한 예제를 시도해 봅시다. 다음 명령은 현재 날짜를 계산합니다.

sqlite> SELECT date('now');
2013-05-07

다음 명령은 이번 달의 마지막 날을 계산합니다.

sqlite> SELECT date('now','start of month','+1 month','-1 day');
2013-05-31

다음 명령은 주어진 UNIX 타임 스탬프 1092941466에 대한 날짜와 시간을 계산합니다.

sqlite> SELECT datetime(1092941466, 'unixepoch');
2004-08-19 18:51:06

다음 명령은 주어진 UNIX 타임 스탬프 1092941466에 대한 날짜와 시간을 계산하고 현지 시간대를 보정합니다.

sqlite> SELECT datetime(1092941466, 'unixepoch', 'localtime');
2004-08-19 13:51:06

다음 명령은 현재 UNIX 타임 스탬프를 계산합니다.

sqlite> SELECT strftime('%s','now');
1393348134

다음 명령은 미국 독립 선언서에 서명 한 이후의 일수를 계산합니다.

sqlite> SELECT julianday('now') - julianday('1776-07-04');
86798.7094695023

다음 명령은 2004 년 특정 순간 이후의 초 수를 계산합니다.

sqlite> SELECT strftime('%s','now') - strftime('%s','2004-01-01 02:34:56');
295001572

다음 명령은 현재 연도의 10 월 첫 번째 화요일 날짜를 계산합니다.

sqlite> SELECT date('now','start of year','+9 months','weekday 2');
2013-10-01

다음 명령은 UNIX 시대 이후의 시간을 초 단위로 계산합니다 (예 : strftime ( '% s', 'now')).

sqlite> SELECT (julianday('now') - 2440587.5)*86400.0;
1367926077.12598

날짜 형식을 지정할 때 UTC와 현지 시간 값을 변환하려면 다음과 같이 utc 또는 localtime 수정자를 사용하십시오.

sqlite> SELECT time('12:00', 'localtime');
05:00:00
sqlite> SELECT time('12:00', 'utc');
19:00:00

SQLite에는 문자열 또는 숫자 데이터 처리를 수행하는 많은 내장 함수가 있습니다. 다음은 몇 가지 유용한 SQLite 내장 함수 목록이며 모두 대소 문자를 구분하지 않으므로 이러한 함수를 소문자 형식이나 대문자 또는 혼합 형식으로 사용할 수 있습니다. 자세한 내용은 SQLite에 대한 공식 문서를 확인할 수 있습니다.

Sr. 아니. 기능 및 설명
1

SQLite COUNT Function

SQLite COUNT 집계 함수는 데이터베이스 테이블의 행 수를 계산하는 데 사용됩니다.
2

SQLite MAX Function

SQLite MAX 집계 함수를 사용하면 특정 열에 대해 가장 높은 (최대) 값을 선택할 수 있습니다.
삼

SQLite MIN Function

SQLite MIN 집계 함수를 사용하면 특정 열에 대해 가장 낮은 (최소) 값을 선택할 수 있습니다.
4

SQLite AVG Function

SQLite AVG 집계 함수는 특정 테이블 열의 평균 값을 선택합니다.
5

SQLite SUM Function

SQLite SUM 집계 함수를 사용하면 숫자 열의 합계를 선택할 수 있습니다.
6

SQLite RANDOM Function

SQLite RANDOM 함수는 -9223372036854775808에서 +9223372036854775807 사이의 의사 난수 정수를 반환합니다.
7

SQLite ABS Function

SQLite ABS 함수는 숫자 인수의 절대 값을 반환합니다.
8

SQLite UPPER Function

SQLite UPPER 함수는 문자열을 대문자로 변환합니다.
9

SQLite LOWER Function

SQLite LOWER 함수는 문자열을 소문자로 변환합니다.
10

SQLite LENGTH Function

SQLite LENGTH 함수는 문자열의 길이를 반환합니다.
11

SQLite sqlite_version Function

SQLite sqlite_version 함수는 SQLite 라이브러리의 버전을 반환합니다.

위에서 언급 한 함수에 대한 예제를 제공하기 전에 다음 레코드가있는 COMPANY 테이블을 고려하십시오.

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0

SQLite COUNT 함수

SQLite COUNT 집계 함수는 데이터베이스 테이블의 행 수를 계산하는 데 사용됩니다. 다음은 예입니다-

sqlite> SELECT count(*) FROM COMPANY;

위의 SQLite SQL 문은 다음을 생성합니다.

count(*)
----------
7

SQLite MAX 기능

SQLite MAX 집계 함수를 사용하면 특정 열에 대해 가장 높은 (최대) 값을 선택할 수 있습니다. 다음은 예입니다-

sqlite> SELECT max(salary) FROM COMPANY;

위의 SQLite SQL 문은 다음을 생성합니다.

max(salary)
-----------
85000.0

SQLite MIN 함수

SQLite MIN 집계 함수를 사용하면 특정 열에 대해 가장 낮은 (최소) 값을 선택할 수 있습니다. 다음은 예입니다-

sqlite> SELECT min(salary) FROM COMPANY;

위의 SQLite SQL 문은 다음을 생성합니다.

min(salary)
-----------
10000.0

SQLite AVG 함수

SQLite AVG 집계 함수는 특정 테이블 열에 대한 평균 값을 선택합니다. 다음은 예입니다-

sqlite> SELECT avg(salary) FROM COMPANY;

위의 SQLite SQL 문은 다음을 생성합니다.

avg(salary)
----------------
37142.8571428572

SQLite SUM 함수

SQLite SUM 집계 함수를 사용하면 숫자 열의 합계를 선택할 수 있습니다. 다음은 예입니다-

sqlite> SELECT sum(salary) FROM COMPANY;

위의 SQLite SQL 문은 다음을 생성합니다.

sum(salary)
-----------
260000.0

SQLite RANDOM 기능

SQLite RANDOM 함수는 -9223372036854775808에서 +9223372036854775807 사이의 의사 난수 정수를 반환합니다. 다음은 예입니다-

sqlite> SELECT random() AS Random;

위의 SQLite SQL 문은 다음을 생성합니다.

Random
-------------------
5876796417670984050

SQLite ABS 기능

SQLite ABS 함수는 숫자 인수의 절대 값을 반환합니다. 다음은 예입니다-

sqlite> SELECT abs(5), abs(-15), abs(NULL), abs(0), abs("ABC");

위의 SQLite SQL 문은 다음을 생성합니다.

abs(5)      abs(-15)    abs(NULL)   abs(0)      abs("ABC")
----------  ----------  ----------  ----------  ----------
5           15                      0           0.0

SQLite UPPER 함수

SQLite UPPER 함수는 문자열을 대문자로 변환합니다. 다음은 예입니다-

sqlite> SELECT upper(name) FROM COMPANY;

위의 SQLite SQL 문은 다음을 생성합니다.

upper(name)
-----------
PAUL
ALLEN
TEDDY
MARK
DAVID
KIM
JAMES

SQLite LOWER 함수

SQLite LOWER 함수는 문자열을 소문자로 변환합니다. 다음은 예입니다-

sqlite> SELECT lower(name) FROM COMPANY;

위의 SQLite SQL 문은 다음을 생성합니다.

lower(name)
-----------
paul
allen
teddy
mark
david
kim
james

SQLite LENGTH 함수

SQLite LENGTH 함수는 문자열의 길이를 반환합니다. 다음은 예입니다-

sqlite> SELECT name, length(name) FROM COMPANY;

위의 SQLite SQL 문은 다음을 생성합니다.

NAME        length(name)
----------  ------------
Paul        4
Allen       5
Teddy       5
Mark        4
David       5
Kim         3
James       5

SQLite sqlite_version 함수

SQLite sqlite_version 함수는 SQLite 라이브러리의 버전을 반환합니다. 다음은 예입니다-

sqlite> SELECT sqlite_version() AS 'SQLite Version';

위의 SQLite SQL 문은 다음을 생성합니다.

SQLite Version
--------------
3.6.20

이 장에서는 C / C ++ 프로그램에서 SQLite를 사용하는 방법을 배웁니다.

설치

C / C ++ 프로그램에서 SQLite 사용을 시작하기 전에 컴퓨터에 SQLite 라이브러리가 설정되어 있는지 확인해야합니다. SQLite 설치 장을 확인하여 설치 프로세스를 이해할 수 있습니다.

C / C ++ 인터페이스 API

다음은 중요한 C / C ++ SQLite 인터페이스 루틴으로, C / C ++ 프로그램에서 SQLite 데이터베이스로 작업하기위한 요구 사항을 충족 할 수 있습니다. 보다 정교한 애플리케이션을 찾고 있다면 SQLite 공식 문서를 살펴볼 수 있습니다.

Sr. 아니. API 및 설명
1

sqlite3_open(const char *filename, sqlite3 **ppDb)

이 루틴은 SQLite 데이터베이스 파일에 대한 연결을 열고 다른 SQLite 루틴에서 사용할 데이터베이스 연결 개체를 반환합니다.

경우 파일 이름 '메모리', sqlite3_open ()는 세션 기간 동안 지속 RAM의 메모리 데이터베이스를 만듭니다 인수는 NULL 또는이다.

파일 이름이 NULL이 아니면 sqlite3_open ()은 해당 값을 사용하여 데이터베이스 파일을 열려고합니다. 해당 이름의 파일이 없으면 sqlite3_open ()은 해당 이름으로 새 데이터베이스 파일을 엽니 다.
2

sqlite3_exec(sqlite3*, const char *sql, sqlite_callback, void *data, char **errmsg)

이 루틴은 둘 이상의 SQL 명령으로 구성 될 수있는 sql 인수가 제공하는 SQL 명령을 실행하는 빠르고 쉬운 방법을 제공합니다.

여기에서 첫 번째 인수 sqlite3 은 개방형 데이터베이스 객체이고 sqlite_callback 은 데이터 가 첫 번째 인수 인 콜백 이며 루틴에 의해 발생한 오류를 캡처하기 위해 errmsg가 반환됩니다.

SQLite3_exec () 루틴은 sql 인수가 문자열 끝에 도달하거나 오류가 발생할 때까지.
삼

sqlite3_close(sqlite3*)

이 루틴은 sqlite3_open ()에 대한 호출로 이전에 열린 데이터베이스 연결을 닫습니다. 연결과 관련된 모든 준비된 문은 연결을 닫기 전에 완료되어야합니다.

완료되지 않은 쿼리가 남아있는 경우 sqlite3_close ()는 완료되지 않은 문으로 인해 닫을 수 없음 오류 메시지와 함께 SQLITE_BUSY를 반환합니다.

데이터베이스에 연결

다음 C 코드 세그먼트는 기존 데이터베이스에 연결하는 방법을 보여줍니다. 데이터베이스가 존재하지 않으면 생성되고 마지막으로 데이터베이스 개체가 반환됩니다.

#include <stdio.h>
#include <sqlite3.h> 

int main(int argc, char* argv[]) {
   sqlite3 *db;
   char *zErrMsg = 0;
   int rc;

   rc = sqlite3_open("test.db", &db);

   if( rc ) {
      fprintf(stderr, "Can't open database: %s\n", sqlite3_errmsg(db));
      return(0);
   } else {
      fprintf(stderr, "Opened database successfully\n");
   }
   sqlite3_close(db);
}

이제 위의 프로그램을 컴파일하고 실행하여 데이터베이스를 생성하겠습니다. test.db현재 디렉토리에서. 요구 사항에 따라 경로를 변경할 수 있습니다.

$gcc test.c -l sqlite3
$./a.out
Opened database successfully

C ++ 소스 코드를 사용하려는 경우 다음과 같이 코드를 컴파일 할 수 있습니다.

$g++ test.c -l sqlite3

여기에서는 C 프로그램에 필요한 기능을 제공하기 위해 프로그램을 sqlite3 라이브러리와 연결합니다. 그러면 디렉토리에 test.db 데이터베이스 파일이 생성되고 다음과 같은 결과가 나타납니다.

-rwxr-xr-x. 1 root root 7383 May 8 02:06 a.out
-rw-r--r--. 1 root root  323 May 8 02:05 test.c
-rw-r--r--. 1 root root    0 May 8 02:06 test.db

테이블 생성

다음 C 코드 세그먼트는 이전에 생성 된 데이터베이스에 테이블을 생성하는 데 사용됩니다-

#include <stdio.h>
#include <stdlib.h>
#include <sqlite3.h> 

static int callback(void *NotUsed, int argc, char **argv, char **azColName) {
   int i;
   for(i = 0; i<argc; i++) {
      printf("%s = %s\n", azColName[i], argv[i] ? argv[i] : "NULL");
   }
   printf("\n");
   return 0;
}

int main(int argc, char* argv[]) {
   sqlite3 *db;
   char *zErrMsg = 0;
   int rc;
   char *sql;

   /* Open database */
   rc = sqlite3_open("test.db", &db);
   
   if( rc ) {
      fprintf(stderr, "Can't open database: %s\n", sqlite3_errmsg(db));
      return(0);
   } else {
      fprintf(stdout, "Opened database successfully\n");
   }

   /* Create SQL statement */
   sql = "CREATE TABLE COMPANY("  \
      "ID INT PRIMARY KEY     NOT NULL," \
      "NAME           TEXT    NOT NULL," \
      "AGE            INT     NOT NULL," \
      "ADDRESS        CHAR(50)," \
      "SALARY         REAL );";

   /* Execute SQL statement */
   rc = sqlite3_exec(db, sql, callback, 0, &zErrMsg);
   
   if( rc != SQLITE_OK ){
      fprintf(stderr, "SQL error: %s\n", zErrMsg);
      sqlite3_free(zErrMsg);
   } else {
      fprintf(stdout, "Table created successfully\n");
   }
   sqlite3_close(db);
   return 0;
}

위의 프로그램이 컴파일되고 실행되면 test.db에 COMPANY 테이블이 생성되고 파일의 최종 목록은 다음과 같습니다.

-rwxr-xr-x. 1 root root 9567 May 8 02:31 a.out
-rw-r--r--. 1 root root 1207 May 8 02:31 test.c
-rw-r--r--. 1 root root 3072 May 8 02:31 test.db

INSERT 작업

다음 C 코드 세그먼트는 위의 예에서 만든 COMPANY 테이블에서 레코드를 만드는 방법을 보여줍니다.

#include <stdio.h>
#include <stdlib.h>
#include <sqlite3.h> 

static int callback(void *NotUsed, int argc, char **argv, char **azColName) {
   int i;
   for(i = 0; i<argc; i++) {
      printf("%s = %s\n", azColName[i], argv[i] ? argv[i] : "NULL");
   }
   printf("\n");
   return 0;
}

int main(int argc, char* argv[]) {
   sqlite3 *db;
   char *zErrMsg = 0;
   int rc;
   char *sql;

   /* Open database */
   rc = sqlite3_open("test.db", &db);
   
   if( rc ) {
      fprintf(stderr, "Can't open database: %s\n", sqlite3_errmsg(db));
      return(0);
   } else {
      fprintf(stderr, "Opened database successfully\n");
   }

   /* Create SQL statement */
   sql = "INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY) "  \
         "VALUES (1, 'Paul', 32, 'California', 20000.00 ); " \
         "INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY) "  \
         "VALUES (2, 'Allen', 25, 'Texas', 15000.00 ); "     \
         "INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY)" \
         "VALUES (3, 'Teddy', 23, 'Norway', 20000.00 );" \
         "INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY)" \
         "VALUES (4, 'Mark', 25, 'Rich-Mond ', 65000.00 );";

   /* Execute SQL statement */
   rc = sqlite3_exec(db, sql, callback, 0, &zErrMsg);
   
   if( rc != SQLITE_OK ){
      fprintf(stderr, "SQL error: %s\n", zErrMsg);
      sqlite3_free(zErrMsg);
   } else {
      fprintf(stdout, "Records created successfully\n");
   }
   sqlite3_close(db);
   return 0;
}

위의 프로그램이 컴파일되고 실행되면 COMPANY 테이블에 주어진 레코드를 생성하고 다음 두 줄을 표시합니다.

Opened database successfully
Records created successfully

SELECT 작업

레코드를 가져 오는 실제 예제를 진행하기 전에 예제에서 사용하는 콜백 함수에 대한 세부 정보를 살펴 보겠습니다. 이 콜백은 SELECT 문에서 결과를 얻는 방법을 제공합니다. 다음과 같은 선언이 있습니다.

typedef int (*sqlite3_callback)(
   void*,    /* Data provided in the 4th argument of sqlite3_exec() */
   int,      /* The number of columns in row */
   char**,   /* An array of strings representing fields in the row */
   char**    /* An array of strings representing column names */
);

위의 콜백이 sqlite_exec () 루틴에서 세 번째 인수로 제공되면 SQLite는 SQL 인수 내에서 실행되는 각 SELECT 문에서 처리 된 각 레코드에 대해이 콜백 함수를 호출합니다.

다음 C 코드 세그먼트는 위의 예에서 생성 된 COMPANY 테이블에서 레코드를 가져오고 표시하는 방법을 보여줍니다.

#include <stdio.h>
#include <stdlib.h>
#include <sqlite3.h> 

static int callback(void *data, int argc, char **argv, char **azColName){
   int i;
   fprintf(stderr, "%s: ", (const char*)data);
   
   for(i = 0; i<argc; i++){
      printf("%s = %s\n", azColName[i], argv[i] ? argv[i] : "NULL");
   }
   
   printf("\n");
   return 0;
}

int main(int argc, char* argv[]) {
   sqlite3 *db;
   char *zErrMsg = 0;
   int rc;
   char *sql;
   const char* data = "Callback function called";

   /* Open database */
   rc = sqlite3_open("test.db", &db);
   
   if( rc ) {
      fprintf(stderr, "Can't open database: %s\n", sqlite3_errmsg(db));
      return(0);
   } else {
      fprintf(stderr, "Opened database successfully\n");
   }

   /* Create SQL statement */
   sql = "SELECT * from COMPANY";

   /* Execute SQL statement */
   rc = sqlite3_exec(db, sql, callback, (void*)data, &zErrMsg);
   
   if( rc != SQLITE_OK ) {
      fprintf(stderr, "SQL error: %s\n", zErrMsg);
      sqlite3_free(zErrMsg);
   } else {
      fprintf(stdout, "Operation done successfully\n");
   }
   sqlite3_close(db);
   return 0;
}

위의 프로그램을 컴파일하여 실행하면 다음과 같은 결과가 나옵니다.

Opened database successfully
Callback function called: ID = 1
NAME = Paul
AGE = 32
ADDRESS = California
SALARY = 20000.0

Callback function called: ID = 2
NAME = Allen
AGE = 25
ADDRESS = Texas
SALARY = 15000.0

Callback function called: ID = 3
NAME = Teddy
AGE = 23
ADDRESS = Norway
SALARY = 20000.0

Callback function called: ID = 4
NAME = Mark
AGE = 25
ADDRESS = Rich-Mond
SALARY = 65000.0

Operation done successfully

업데이트 작업

다음 C 코드 세그먼트는 UPDATE 문을 사용하여 레코드를 업데이트 한 다음 COMPANY 테이블에서 업데이트 된 레코드를 가져와 표시하는 방법을 보여줍니다.

#include <stdio.h>
#include <stdlib.h>
#include <sqlite3.h> 

static int callback(void *data, int argc, char **argv, char **azColName){
   int i;
   fprintf(stderr, "%s: ", (const char*)data);
   
   for(i = 0; i<argc; i++) {
      printf("%s = %s\n", azColName[i], argv[i] ? argv[i] : "NULL");
   }
   printf("\n");
   return 0;
}

int main(int argc, char* argv[]) {
   sqlite3 *db;
   char *zErrMsg = 0;
   int rc;
   char *sql;
   const char* data = "Callback function called";

   /* Open database */
   rc = sqlite3_open("test.db", &db);
   
   if( rc ) {
      fprintf(stderr, "Can't open database: %s\n", sqlite3_errmsg(db));
      return(0);
   } else {
      fprintf(stderr, "Opened database successfully\n");
   }

   /* Create merged SQL statement */
   sql = "UPDATE COMPANY set SALARY = 25000.00 where ID=1; " \
         "SELECT * from COMPANY";

   /* Execute SQL statement */
   rc = sqlite3_exec(db, sql, callback, (void*)data, &zErrMsg);
   
   if( rc != SQLITE_OK ) {
      fprintf(stderr, "SQL error: %s\n", zErrMsg);
      sqlite3_free(zErrMsg);
   } else {
      fprintf(stdout, "Operation done successfully\n");
   }
   sqlite3_close(db);
   return 0;
}

위의 프로그램을 컴파일하여 실행하면 다음과 같은 결과가 나옵니다.

Opened database successfully
Callback function called: ID = 1
NAME = Paul
AGE = 32
ADDRESS = California
SALARY = 25000.0

Callback function called: ID = 2
NAME = Allen
AGE = 25
ADDRESS = Texas
SALARY = 15000.0

Callback function called: ID = 3
NAME = Teddy
AGE = 23
ADDRESS = Norway
SALARY = 20000.0

Callback function called: ID = 4
NAME = Mark
AGE = 25
ADDRESS = Rich-Mond
SALARY = 65000.0

Operation done successfully

작업 삭제

다음 C 코드 세그먼트는 DELETE 문을 사용하여 레코드를 삭제 한 다음 COMPANY 테이블에서 나머지 레코드를 가져와 표시하는 방법을 보여줍니다.

#include <stdio.h>
#include <stdlib.h>
#include <sqlite3.h> 

static int callback(void *data, int argc, char **argv, char **azColName) {
   int i;
   fprintf(stderr, "%s: ", (const char*)data);
   
   for(i = 0; i<argc; i++) {
      printf("%s = %s\n", azColName[i], argv[i] ? argv[i] : "NULL");
   }
   printf("\n");
   return 0;
}

int main(int argc, char* argv[]) {
   sqlite3 *db;
   char *zErrMsg = 0;
   int rc;
   char *sql;
   const char* data = "Callback function called";

   /* Open database */
   rc = sqlite3_open("test.db", &db);
   
   if( rc ) {
      fprintf(stderr, "Can't open database: %s\n", sqlite3_errmsg(db));
      return(0);
   } else {
      fprintf(stderr, "Opened database successfully\n");
   }

   /* Create merged SQL statement */
   sql = "DELETE from COMPANY where ID=2; " \
         "SELECT * from COMPANY";

   /* Execute SQL statement */
   rc = sqlite3_exec(db, sql, callback, (void*)data, &zErrMsg);
   
   if( rc != SQLITE_OK ) {
      fprintf(stderr, "SQL error: %s\n", zErrMsg);
      sqlite3_free(zErrMsg);
   } else {
      fprintf(stdout, "Operation done successfully\n");
   }
   sqlite3_close(db);
   return 0;
}

위의 프로그램을 컴파일하여 실행하면 다음과 같은 결과가 나옵니다.

Opened database successfully
Callback function called: ID = 1
NAME = Paul
AGE = 32
ADDRESS = California
SALARY = 20000.0

Callback function called: ID = 3
NAME = Teddy
AGE = 23
ADDRESS = Norway
SALARY = 20000.0

Callback function called: ID = 4
NAME = Mark
AGE = 25
ADDRESS = Rich-Mond
SALARY = 65000.0

Operation done successfully

이 장에서는 Java 프로그램에서 SQLite를 사용하는 방법을 배웁니다.

설치

Java 프로그램에서 SQLite 사용을 시작하기 전에 컴퓨터에 SQLite JDBC 드라이버 및 Java가 설정되어 있는지 확인해야합니다. 컴퓨터에서 Java 설치에 대한 Java 자습서를 확인할 수 있습니다. 이제 SQLite JDBC 드라이버를 설정하는 방법을 살펴 보겠습니다.

  • sqlite-jdbc 저장소 에서 최신 버전의 sqlite-jdbc- (VERSION) .jar 을 다운로드 합니다.

  • 다운로드 한 jar 파일 sqlite-jdbc- (VERSION) .jar 을 클래스 경로에 추가하거나 다음 예제에 설명 된대로 -classpath 옵션과 함께 사용할 수 있습니다.

다음 섹션에서는 Java JDBC 개념에 대한 지식이 거의 없다고 가정합니다. 그렇지 않은 경우 아래에 설명 된 개념에 익숙해 지도록 JDBC Tutorial 과 함께 30 분을 보내는 것이 좋습니다 .

데이터베이스에 연결

다음 Java 프로그램은 기존 데이터베이스에 연결하는 방법을 보여줍니다. 데이터베이스가 존재하지 않으면 생성되고 마지막으로 데이터베이스 개체가 반환됩니다.

import java.sql.*;

public class SQLiteJDBC {
  public static void main( String args[] ) {
      Connection c = null;
      
      try {
         Class.forName("org.sqlite.JDBC");
         c = DriverManager.getConnection("jdbc:sqlite:test.db");
      } catch ( Exception e ) {
         System.err.println( e.getClass().getName() + ": " + e.getMessage() );
         System.exit(0);
      }
      System.out.println("Opened database successfully");
   }
}

이제 위의 프로그램을 컴파일하고 실행하여 데이터베이스를 생성하겠습니다. test.db현재 디렉토리에서. 요구 사항에 따라 경로를 변경할 수 있습니다. JDBC 드라이버 sqlite-jdbc-3.7.2.jar 의 현재 버전 이 현재 경로에서 사용 가능 하다고 가정합니다 .

$javac SQLiteJDBC.java $java -classpath ".:sqlite-jdbc-3.7.2.jar" SQLiteJDBC
Open database successfully

Windows 시스템을 사용하려는 경우 다음과 같이 코드를 컴파일하고 실행할 수 있습니다.

$javac SQLiteJDBC.java $java -classpath ".;sqlite-jdbc-3.7.2.jar" SQLiteJDBC
Opened database successfully

테이블 생성

다음 자바 프로그램은 이전에 생성 된 데이터베이스에 테이블을 생성하는 데 사용됩니다.

import java.sql.*;

public class SQLiteJDBC {

   public static void main( String args[] ) {
      Connection c = null;
      Statement stmt = null;
      
      try {
         Class.forName("org.sqlite.JDBC");
         c = DriverManager.getConnection("jdbc:sqlite:test.db");
         System.out.println("Opened database successfully");

         stmt = c.createStatement();
         String sql = "CREATE TABLE COMPANY " +
                        "(ID INT PRIMARY KEY     NOT NULL," +
                        " NAME           TEXT    NOT NULL, " + 
                        " AGE            INT     NOT NULL, " + 
                        " ADDRESS        CHAR(50), " + 
                        " SALARY         REAL)"; 
         stmt.executeUpdate(sql);
         stmt.close();
         c.close();
      } catch ( Exception e ) {
         System.err.println( e.getClass().getName() + ": " + e.getMessage() );
         System.exit(0);
      }
      System.out.println("Table created successfully");
   }
}

위의 프로그램이 컴파일되고 실행되면 COMPANY 테이블이 생성됩니다. test.db 파일의 최종 목록은 다음과 같습니다.

-rw-r--r--. 1 root root 3201128 Jan 22 19:04 sqlite-jdbc-3.7.2.jar
-rw-r--r--. 1 root root    1506 May  8 05:43 SQLiteJDBC.class
-rw-r--r--. 1 root root     832 May  8 05:42 SQLiteJDBC.java
-rw-r--r--. 1 root root    3072 May  8 05:43 test.db

INSERT 작업

다음 Java 프로그램은 위 예제에서 생성 된 COMPANY 테이블에 레코드를 생성하는 방법을 보여줍니다.

import java.sql.*;

public class SQLiteJDBC {

   public static void main( String args[] ) {
      Connection c = null;
      Statement stmt = null;
      
      try {
         Class.forName("org.sqlite.JDBC");
         c = DriverManager.getConnection("jdbc:sqlite:test.db");
         c.setAutoCommit(false);
         System.out.println("Opened database successfully");

         stmt = c.createStatement();
         String sql = "INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY) " +
                        "VALUES (1, 'Paul', 32, 'California', 20000.00 );"; 
         stmt.executeUpdate(sql);

         sql = "INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY) " +
                  "VALUES (2, 'Allen', 25, 'Texas', 15000.00 );"; 
         stmt.executeUpdate(sql);

         sql = "INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY) " +
                  "VALUES (3, 'Teddy', 23, 'Norway', 20000.00 );"; 
         stmt.executeUpdate(sql);

         sql = "INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY) " +
                  "VALUES (4, 'Mark', 25, 'Rich-Mond ', 65000.00 );"; 
         stmt.executeUpdate(sql);

         stmt.close();
         c.commit();
         c.close();
      } catch ( Exception e ) {
         System.err.println( e.getClass().getName() + ": " + e.getMessage() );
         System.exit(0);
      }
      System.out.println("Records created successfully");
   }
}

위의 프로그램이 컴파일되고 실행되면 COMPANY 테이블에 주어진 레코드를 생성하고 다음 두 줄을 표시합니다.

Opened database successfully
Records created successfully

SELECT 작업

다음 Java 프로그램은 위 예제에서 생성 된 COMPANY 테이블에서 레코드를 가져 와서 표시하는 방법을 보여줍니다.

import java.sql.*;

public class SQLiteJDBC {

  public static void main( String args[] ) {

   Connection c = null;
   Statement stmt = null;
   try {
      Class.forName("org.sqlite.JDBC");
      c = DriverManager.getConnection("jdbc:sqlite:test.db");
      c.setAutoCommit(false);
      System.out.println("Opened database successfully");

      stmt = c.createStatement();
      ResultSet rs = stmt.executeQuery( "SELECT * FROM COMPANY;" );
      
      while ( rs.next() ) {
         int id = rs.getInt("id");
         String  name = rs.getString("name");
         int age  = rs.getInt("age");
         String  address = rs.getString("address");
         float salary = rs.getFloat("salary");
         
         System.out.println( "ID = " + id );
         System.out.println( "NAME = " + name );
         System.out.println( "AGE = " + age );
         System.out.println( "ADDRESS = " + address );
         System.out.println( "SALARY = " + salary );
         System.out.println();
      }
      rs.close();
      stmt.close();
      c.close();
   } catch ( Exception e ) {
      System.err.println( e.getClass().getName() + ": " + e.getMessage() );
      System.exit(0);
   }
   System.out.println("Operation done successfully");
  }
}

위의 프로그램을 컴파일하여 실행하면 다음과 같은 결과가 나옵니다.

Opened database successfully
ID = 1
NAME = Paul
AGE = 32
ADDRESS = California
SALARY = 20000.0

ID = 2
NAME = Allen
AGE = 25
ADDRESS = Texas
SALARY = 15000.0

ID = 3
NAME = Teddy
AGE = 23
ADDRESS = Norway
SALARY = 20000.0

ID = 4
NAME = Mark
AGE = 25
ADDRESS = Rich-Mond
SALARY = 65000.0

Operation done successfully

업데이트 작업

다음 Java 코드는 UPDATE 문을 사용하여 레코드를 업데이트 한 다음 COMPANY 테이블에서 업데이트 된 레코드를 가져와 표시하는 방법을 보여줍니다.

import java.sql.*;

public class SQLiteJDBC {

  public static void main( String args[] ) {
  
   Connection c = null;
   Statement stmt = null;
   
   try {
      Class.forName("org.sqlite.JDBC");
      c = DriverManager.getConnection("jdbc:sqlite:test.db");
      c.setAutoCommit(false);
      System.out.println("Opened database successfully");

      stmt = c.createStatement();
      String sql = "UPDATE COMPANY set SALARY = 25000.00 where ID=1;";
      stmt.executeUpdate(sql);
      c.commit();

      ResultSet rs = stmt.executeQuery( "SELECT * FROM COMPANY;" );
      
      while ( rs.next() ) {
         int id = rs.getInt("id");
         String  name = rs.getString("name");
         int age  = rs.getInt("age");
         String  address = rs.getString("address");
         float salary = rs.getFloat("salary");
         
         System.out.println( "ID = " + id );
         System.out.println( "NAME = " + name );
         System.out.println( "AGE = " + age );
         System.out.println( "ADDRESS = " + address );
         System.out.println( "SALARY = " + salary );
         System.out.println();
      }
      rs.close();
      stmt.close();
      c.close();
   } catch ( Exception e ) {
      System.err.println( e.getClass().getName() + ": " + e.getMessage() );
      System.exit(0);
   }
    System.out.println("Operation done successfully");
   }
}

위의 프로그램을 컴파일하여 실행하면 다음과 같은 결과가 나옵니다.

Opened database successfully
ID = 1
NAME = Paul
AGE = 32
ADDRESS = California
SALARY = 25000.0

ID = 2
NAME = Allen
AGE = 25
ADDRESS = Texas
SALARY = 15000.0

ID = 3
NAME = Teddy
AGE = 23
ADDRESS = Norway
SALARY = 20000.0

ID = 4
NAME = Mark
AGE = 25
ADDRESS = Rich-Mond
SALARY = 65000.0

Operation done successfully

작업 삭제

다음 Java 코드는 DELETE 문을 사용하여 레코드를 삭제 한 다음 COMPANY 테이블에서 나머지 레코드를 가져와 표시하는 방법을 보여줍니다.

import java.sql.*;

public class SQLiteJDBC {

   public static void main( String args[] ) {
      Connection c = null;
      Statement stmt = null;
      
      try {
         Class.forName("org.sqlite.JDBC");
         c = DriverManager.getConnection("jdbc:sqlite:test.db");
         c.setAutoCommit(false);
         System.out.println("Opened database successfully");

         stmt = c.createStatement();
         String sql = "DELETE from COMPANY where ID=2;";
         stmt.executeUpdate(sql);
         c.commit();

         ResultSet rs = stmt.executeQuery( "SELECT * FROM COMPANY;" );
         
         while ( rs.next() ) {
         int id = rs.getInt("id");
         String  name = rs.getString("name");
         int age  = rs.getInt("age");
         String  address = rs.getString("address");
         float salary = rs.getFloat("salary");
         
         System.out.println( "ID = " + id );
         System.out.println( "NAME = " + name );
         System.out.println( "AGE = " + age );
         System.out.println( "ADDRESS = " + address );
         System.out.println( "SALARY = " + salary );
         System.out.println();
      }
      rs.close();
      stmt.close();
      c.close();
      } catch ( Exception e ) {
         System.err.println( e.getClass().getName() + ": " + e.getMessage() );
         System.exit(0);
      }
      System.out.println("Operation done successfully");
   }
}

위의 프로그램을 컴파일하여 실행하면 다음과 같은 결과가 나옵니다.

Opened database successfully
ID = 1
NAME = Paul
AGE = 32
ADDRESS = California
SALARY = 25000.0

ID = 3
NAME = Teddy
AGE = 23
ADDRESS = Norway
SALARY = 20000.0

ID = 4
NAME = Mark
AGE = 25
ADDRESS = Rich-Mond
SALARY = 65000.0

Operation done successfully

이 장에서는 PHP 프로그램에서 SQLite를 사용하는 방법을 배웁니다.

설치

SQLite3 확장은 PHP 5.3.0부터 기본적으로 활성화됩니다. 다음을 사용하여 비활성화 할 수 있습니다.--without-sqlite3 컴파일 타임에.

Windows 사용자는이 확장을 사용하기 위해 php_sqlite3.dll을 활성화해야합니다. 이 DLL은 PHP 5.3.0부터 PHP의 Windows 배포판에 포함되어 있습니다.

자세한 설치 지침은 PHP 튜토리얼과 공식 웹 사이트를 참조하십시오.

PHP 인터페이스 API

다음은 PHP 프로그램에서 SQLite 데이터베이스로 작업하기위한 요구 사항을 충족 할 수있는 중요한 PHP 루틴입니다. 더 정교한 애플리케이션을 찾고 있다면 PHP 공식 문서를 살펴볼 수 있습니다.

Sr. 아니. API 및 설명
1

public void SQLite3::open ( filename, flags, encryption_key )

SQLite 3 데이터베이스를 엽니 다. 빌드에 암호화가 포함 된 경우 키 사용을 시도합니다.

경우 파일 이름은 로 주어진다':memory:', SQLite3 :: open ()은 세션 기간 동안 만 지속되는 RAM에 메모리 내 데이터베이스를 생성합니다.

파일 이름이 실제 장치 파일 이름이면 SQLite3 :: open ()은 해당 값을 사용하여 데이터베이스 파일을 열려고합니다. 해당 이름의 파일이 없으면 해당 이름의 새 데이터베이스 파일이 생성됩니다.

SQLite 데이터베이스를 여는 방법을 결정하는 데 사용되는 선택적 플래그입니다. 기본적으로 open은 SQLITE3_OPEN_READWRITE | SQLITE3_OPEN_CREATE.
2

public bool SQLite3::exec ( string $query )

이 루틴은 둘 이상의 SQL 명령으로 구성 될 수있는 sql 인수가 제공하는 SQL 명령을 실행하는 빠르고 쉬운 방법을 제공합니다. 이 루틴은 주어진 데이터베이스에 대해 결과없는 쿼리를 실행하는 데 사용됩니다.
삼

public SQLite3Result SQLite3::query ( string $query )

이 루틴은 SQL 쿼리를 실행하여 SQLite3Result 쿼리가 결과를 반환하는 경우 개체입니다.
4

public int SQLite3::lastErrorCode ( void )

이 루틴은 가장 최근에 실패한 SQLite 요청의 숫자 결과 코드를 반환합니다.
5

public string SQLite3::lastErrorMsg ( void )

이 루틴은 가장 최근에 실패한 SQLite 요청을 설명하는 영어 텍스트를 반환합니다.
6

public int SQLite3::changes ( void )

이 루틴은 최신 SQL 문에 의해 업데이트, 삽입 또는 삭제 된 데이터베이스 행 수를 반환합니다.
7

public bool SQLite3::close ( void )

이 루틴은 SQLite3 :: open ()에 대한 호출로 이전에 열린 데이터베이스 연결을 닫습니다.
8

public string SQLite3::escapeString ( string $value )

이 루틴은 SQL 문에 안전하게 포함하기 위해 적절하게 이스케이프 된 문자열을 리턴합니다.

데이터베이스에 연결

다음 PHP 코드는 기존 데이터베이스에 연결하는 방법을 보여줍니다. 데이터베이스가 없으면 생성되고 마지막으로 데이터베이스 개체가 반환됩니다.

<?php
   class MyDB extends SQLite3 {
      function __construct() {
         $this->open('test.db');
      }
   }
   $db = new MyDB(); if(!$db) {
      echo $db->lastErrorMsg();
   } else {
      echo "Opened database successfully\n";
   }
?>

이제 위의 프로그램을 실행하여 데이터베이스를 생성하겠습니다. test.db현재 디렉토리에서. 요구 사항에 따라 경로를 변경할 수 있습니다. 데이터베이스가 성공적으로 생성되면 다음 메시지가 표시됩니다.

Open database successfully

테이블 생성

다음 PHP 프로그램을 사용하여 이전에 생성 된 데이터베이스에 테이블을 생성합니다.

<?php
   class MyDB extends SQLite3 {
      function __construct() {
         $this->open('test.db');
      }
   }
   $db = new MyDB(); if(!$db) {
      echo $db->lastErrorMsg(); } else { echo "Opened database successfully\n"; } $sql =<<<EOF
      CREATE TABLE COMPANY
      (ID INT PRIMARY KEY     NOT NULL,
      NAME           TEXT    NOT NULL,
      AGE            INT     NOT NULL,
      ADDRESS        CHAR(50),
      SALARY         REAL);
EOF;

   $ret = $db->exec($sql); if(!$ret){
      echo $db->lastErrorMsg(); } else { echo "Table created successfully\n"; } $db->close();
?>

위의 프로그램이 실행되면 COMPANY 테이블이 생성됩니다. test.db 다음 메시지가 표시됩니다.

Opened database successfully
Table created successfully

INSERT 작업

아래의 PHP 프로그램은 위 예제에서 생성 한 COMPANY 테이블에 레코드를 생성하는 방법을 보여줍니다.

<?php
   class MyDB extends SQLite3 {
      function __construct() {
         $this->open('test.db'); } } $db = new MyDB();
   if(!$db){ echo $db->lastErrorMsg();
   } else {
      echo "Opened database successfully\n";
   }

   $sql =<<<EOF INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY) VALUES (1, 'Paul', 32, 'California', 20000.00 ); INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY) VALUES (2, 'Allen', 25, 'Texas', 15000.00 ); INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY) VALUES (3, 'Teddy', 23, 'Norway', 20000.00 ); INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY) VALUES (4, 'Mark', 25, 'Rich-Mond ', 65000.00 ); EOF; $ret = $db->exec($sql);
   if(!$ret) { echo $db->lastErrorMsg();
   } else {
      echo "Records created successfully\n";
   }
   $db->close();
?>

위의 프로그램이 실행되면 COMPANY 테이블에 주어진 레코드를 생성하고 다음 두 줄을 표시합니다.

Opened database successfully
Records created successfully

SELECT 작업

다음 PHP 프로그램은 위의 예에서 생성 된 COMPANY 테이블에서 레코드를 가져오고 표시하는 방법을 보여줍니다.

<?php
   class MyDB extends SQLite3 {
      function __construct() {
         $this->open('test.db');
      }
   }
   
   $db = new MyDB(); if(!$db) {
      echo $db->lastErrorMsg(); } else { echo "Opened database successfully\n"; } $sql =<<<EOF
      SELECT * from COMPANY;
EOF;

   $ret = $db->query($sql); while($row = $ret->fetchArray(SQLITE3_ASSOC) ) { echo "ID = ". $row['ID'] . "\n";
      echo "NAME = ". $row['NAME'] ."\n"; echo "ADDRESS = ". $row['ADDRESS'] ."\n";
      echo "SALARY = ".$row['SALARY'] ."\n\n"; } echo "Operation done successfully\n"; $db->close();
?>

위 프로그램을 실행하면 다음과 같은 결과가 나옵니다.

Opened database successfully
ID = 1
NAME = Paul
ADDRESS = California
SALARY = 20000

ID = 2
NAME = Allen
ADDRESS = Texas
SALARY = 15000

ID = 3
NAME = Teddy
ADDRESS = Norway
SALARY = 20000

ID = 4
NAME = Mark
ADDRESS = Rich-Mond
SALARY = 65000

Operation done successfully

업데이트 작업

다음 PHP 코드는 UPDATE 문을 사용하여 레코드를 업데이트 한 다음 COMPANY 테이블에서 업데이트 된 레코드를 가져와 표시하는 방법을 보여줍니다.

<?php
   class MyDB extends SQLite3 {
      function __construct() {
         $this->open('test.db'); } } $db = new MyDB();
   if(!$db) { echo $db->lastErrorMsg();
   } else {
      echo "Opened database successfully\n";
   }
   $sql =<<<EOF UPDATE COMPANY set SALARY = 25000.00 where ID=1; EOF; $ret = $db->exec($sql);
   if(!$ret) { echo $db->lastErrorMsg();
   } else {
      echo $db->changes(), " Record updated successfully\n"; } $sql =<<<EOF
      SELECT * from COMPANY;
EOF;
   
   $ret = $db->query($sql); while($row = $ret->fetchArray(SQLITE3_ASSOC) ) { echo "ID = ". $row['ID'] . "\n";
      echo "NAME = ". $row['NAME'] ."\n"; echo "ADDRESS = ". $row['ADDRESS'] ."\n";
      echo "SALARY = ".$row['SALARY'] ."\n\n"; } echo "Operation done successfully\n"; $db->close();
?>

위 프로그램을 실행하면 다음과 같은 결과가 나옵니다.

Opened database successfully
1 Record updated successfully
ID = 1
NAME = Paul
ADDRESS = California
SALARY = 25000

ID = 2
NAME = Allen
ADDRESS = Texas
SALARY = 15000

ID = 3
NAME = Teddy
ADDRESS = Norway
SALARY = 20000

ID = 4
NAME = Mark
ADDRESS = Rich-Mond
SALARY = 65000

Operation done successfully

작업 삭제

다음 PHP 코드는 DELETE 문을 사용하여 레코드를 삭제 한 다음 COMPANY 테이블에서 나머지 레코드를 가져와 표시하는 방법을 보여줍니다.

<?php
   class MyDB extends SQLite3 {
      function __construct() {
         $this->open('test.db'); } } $db = new MyDB();
   if(!$db) { echo $db->lastErrorMsg();
   } else {
      echo "Opened database successfully\n";
   }
   $sql =<<<EOF DELETE from COMPANY where ID = 2; EOF; $ret = $db->exec($sql);
   if(!$ret){ echo $db->lastErrorMsg();
   } else {
      echo $db->changes(), " Record deleted successfully\n"; } $sql =<<<EOF
      SELECT * from COMPANY;
EOF;
   $ret = $db->query($sql); while($row = $ret->fetchArray(SQLITE3_ASSOC) ) { echo "ID = ". $row['ID'] . "\n";
      echo "NAME = ". $row['NAME'] ."\n"; echo "ADDRESS = ". $row['ADDRESS'] ."\n";
      echo "SALARY = ".$row['SALARY'] ."\n\n"; } echo "Operation done successfully\n"; $db->close();
?>

위 프로그램을 실행하면 다음과 같은 결과가 나옵니다.

Opened database successfully
1 Record deleted successfully
ID = 1
NAME = Paul
ADDRESS = California
SALARY = 25000

ID = 3
NAME = Teddy
ADDRESS = Norway
SALARY = 20000

ID = 4
NAME = Mark
ADDRESS = Rich-Mond
SALARY = 65000

Operation done successfully

이 장에서는 Perl 프로그램에서 SQLite를 사용하는 방법을 배웁니다.

설치

SQLite3는 Perl 프로그래밍 언어를위한 데이터베이스 액세스 모듈 인 Perl DBI 모듈을 사용하여 Perl과 통합 될 수 있습니다. 표준 데이터베이스 인터페이스를 제공하는 메소드, 변수 및 규칙 세트를 정의합니다.

다음은 Linux / UNIX 시스템에 DBI 모듈을 설치하는 간단한 단계입니다.

$ wget http://search.cpan.org/CPAN/authors/id/T/TI/TIMB/DBI-1.625.tar.gz $ tar xvfz DBI-1.625.tar.gz
$ cd DBI-1.625 $ perl Makefile.PL
$ make $ make install

DBI 용 SQLite 드라이버를 설치해야하는 경우 다음과 같이 설치할 수 있습니다.

$ wget http://search.cpan.org/CPAN/authors/id/M/MS/MSERGEANT/DBD-SQLite-1.11.tar.gz $ tar xvfz DBD-SQLite-1.11.tar.gz
$ cd DBD-SQLite-1.11 $ perl Makefile.PL
$ make $ make install

DBI 인터페이스 API

다음은 중요한 DBI 루틴이며 Perl 프로그램에서 SQLite 데이터베이스로 작업하기위한 요구 사항을 충족 할 수 있습니다. 보다 정교한 애플리케이션을 찾고 있다면 Perl DBI 공식 문서를 살펴볼 수 있습니다.

Sr. 아니. API 및 설명
1

DBI->connect($data_source, "", "", \%attr)

요청 된 $ data_source에 대한 데이터베이스 연결 또는 세션을 설정합니다. 연결이 성공하면 데이터베이스 핸들 개체를 반환합니다.

데이터 소스는 다음과 같은 형식을 갖습니다. DBI:SQLite:dbname = 'test.db'여기서 SQLite는 SQLite 드라이버 이름이고 test.db는 SQLite 데이터베이스 파일의 이름입니다. 파일 이름이 다음과 같이 주어지면':memory:', 세션 기간 동안 만 지속되는 RAM에 메모리 내 데이터베이스를 생성합니다.

파일 이름이 실제 장치 파일 이름이면 해당 값을 사용하여 데이터베이스 파일을 열려고합니다. 해당 이름의 파일이 없으면 해당 이름의 새 데이터베이스 파일이 생성됩니다.

두 번째 및 세 번째 매개 변수는 공백 문자열로 유지하고 마지막 매개 변수는 다음 예제와 같이 다양한 속성을 전달하는 것입니다.
2

$dbh->do($sql)

이 루틴은 단일 SQL 문을 준비하고 실행합니다. 영향을 받거나 오류 발생시 정의되지 않은 행 수를 반환합니다. 반환 값 -1은 행 수가 알려지지 않았거나 적용 가능하지 않거나 사용할 수 없음을 의미합니다. 여기서 $ dbh는 DBI-> connect () 호출에 의해 반환 된 핸들입니다.
삼

$dbh->prepare($sql)

이 루틴은 나중에 데이터베이스 엔진에서 실행할 문을 준비하고 문 핸들 개체에 대한 참조를 반환합니다.
4

$sth->execute()

이 루틴은 준비된 명령문을 실행하는 데 필요한 모든 처리를 수행합니다. 오류가 발생하면 undef가 반환됩니다. 성공적인 실행은 영향을받는 행 수에 관계없이 항상 true를 반환합니다. 여기,$sth is a statement handle returned by $dbh-> prepare ($ sql) 호출.
5

$sth->fetchrow_array()

이 루틴은 데이터의 다음 행을 가져 와서 필드 값을 포함하는 목록으로 리턴합니다. Null 필드는 목록에서 undef 값으로 반환됩니다.
6

$DBI::err

이것은 $ h-> err과 동일합니다. $h is any of the handle types like $dbh, $sth, or $drh. 마지막으로 호출 된 드라이버 메서드에서 네이티브 데이터베이스 엔진 오류 코드를 반환합니다.
7

$DBI::errstr

이것은 $ h-> errstr과 동일합니다. $h is any of the handle types like $dbh, $sth, or $drh. 마지막으로 호출 된 DBI 메서드에서 네이티브 데이터베이스 엔진 오류 메시지를 반환합니다.
8

$dbh->disconnect()

이 루틴은 DBI-> connect ()에 대한 호출로 이전에 열린 데이터베이스 연결을 닫습니다.

데이터베이스에 연결

다음 Perl 코드는 기존 데이터베이스에 연결하는 방법을 보여줍니다. 데이터베이스가 존재하지 않으면 생성되고 마지막으로 데이터베이스 개체가 반환됩니다.

#!/usr/bin/perl

use DBI;
use strict;

my $driver   = "SQLite"; 
my $database = "test.db"; my $dsn = "DBI:$driver:dbname=$database";
my $userid = ""; my $password = "";
my $dbh = DBI->connect($dsn, $userid, $password, { RaiseError => 1 }) 
   or die $DBI::errstr;

print "Opened database successfully\n";

이제 위의 프로그램을 실행하여 현재 디렉터리에 test.db 데이터베이스를 생성 해 보겠습니다. 요구 사항에 따라 경로를 변경할 수 있습니다. 위 코드를 sqlite.pl 파일에 보관하고 아래와 같이 실행합니다. 데이터베이스가 성공적으로 생성되면 다음 메시지가 표시됩니다.

$ chmod +x sqlite.pl
$ ./sqlite.pl
Open database successfully

테이블 생성

다음 Perl 프로그램은 이전에 생성 된 데이터베이스에 테이블을 생성하는데 사용됩니다.

#!/usr/bin/perl

use DBI;
use strict;

my $driver   = "SQLite";
my $database = "test.db"; my $dsn = "DBI:$driver:dbname=$database";
my $userid = ""; my $password = "";
my $dbh = DBI->connect($dsn, $userid, $password, { RaiseError => 1 })
   or die $DBI::errstr; print "Opened database successfully\n"; my $stmt = qq(CREATE TABLE COMPANY
   (ID INT PRIMARY KEY     NOT NULL,
      NAME           TEXT    NOT NULL,
      AGE            INT     NOT NULL,
      ADDRESS        CHAR(50),
      SALARY         REAL););

my $rv = $dbh->do($stmt); if($rv < 0) {
   print $DBI::errstr; } else { print "Table created successfully\n"; } $dbh->disconnect();

위의 프로그램이 실행되면 test.db에 COMPANY 테이블이 생성되고 다음과 같은 메시지가 표시됩니다.

Opened database successfully
Table created successfully

NOTE − 작업 중에 다음과 같은 오류가 표시되는 경우 −

DBD::SQLite::st execute failed: not an error(21) at dbdimp.c line 398

이 경우 열기 dbdimp.c file DBD-SQLite 설치에서 사용 가능하며 sqlite3_prepare() 함수를 사용하고 세 번째 인수를 -1 0 대신에. 마지막으로 DBD :: SQLite를 설치합니다. make 그리고 make install 문제를 해결합니다.

INSERT 작업

다음 Perl 프로그램은 위 예제에서 생성 된 COMPANY 테이블에 레코드를 생성하는 방법을 보여줍니다.

#!/usr/bin/perl

use DBI;
use strict;

my $driver = "SQLite"; my $database = "test.db";
my $dsn = "DBI:$driver:dbname=$database"; my $userid = "";
my $password = ""; my $dbh = DBI->connect($dsn, $userid, $password, { RaiseError => 1 }) or die $DBI::errstr;
print "Opened database successfully\n";

my $stmt = qq(INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY) VALUES (1, 'Paul', 32, 'California', 20000.00 )); my $rv = $dbh->do($stmt) or die $DBI::errstr; $stmt = qq(INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY)
               VALUES (2, 'Allen', 25, 'Texas', 15000.00 ));
$rv = $dbh->do($stmt) or die $DBI::errstr;

$stmt = qq(INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY) VALUES (3, 'Teddy', 23, 'Norway', 20000.00 )); $rv = $dbh->do($stmt) or die $DBI::errstr; $stmt = qq(INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY)
               VALUES (4, 'Mark', 25, 'Rich-Mond ', 65000.00 ););

$rv = $dbh->do($stmt) or die $DBI::errstr;

print "Records created successfully\n";
$dbh->disconnect();

위의 프로그램이 실행되면 COMPANY 테이블에 주어진 레코드를 생성하고 다음 두 줄을 표시합니다.

Opened database successfully
Records created successfully

SELECT 작업

다음 Perl 프로그램은 위의 예제에서 생성 된 COMPANY 테이블에서 레코드를 가져 와서 표시하는 방법을 보여줍니다.

#!/usr/bin/perl

use DBI;
use strict;

my $driver = "SQLite";
my $database = "test.db"; my $dsn = "DBI:$driver:dbname=$database";
my $userid = ""; my $password = "";
my $dbh = DBI->connect($dsn, $userid, $password, { RaiseError => 1 })
   or die $DBI::errstr; print "Opened database successfully\n"; my $stmt = qq(SELECT id, name, address, salary from COMPANY;);
my $sth = $dbh->prepare( $stmt ); my $rv = $sth->execute() or die $DBI::errstr;

if($rv < 0) { print $DBI::errstr;
}

while(my @row = $sth->fetchrow_array()) { print "ID = ". $row[0] . "\n";
      print "NAME = ". $row[1] ."\n"; print "ADDRESS = ". $row[2] ."\n";
      print "SALARY =  ". $row[3] ."\n\n"; } print "Operation done successfully\n"; $dbh->disconnect();

위 프로그램을 실행하면 다음과 같은 결과가 나옵니다.

Opened database successfully
ID = 1
NAME = Paul
ADDRESS = California
SALARY =  20000

ID = 2
NAME = Allen
ADDRESS = Texas
SALARY =  15000

ID = 3
NAME = Teddy
ADDRESS = Norway
SALARY =  20000

ID = 4
NAME = Mark
ADDRESS = Rich-Mond
SALARY =  65000

Operation done successfully

업데이트 작업

다음 Perl 코드는 UPDATE 문을 사용하여 레코드를 업데이트 한 다음 COMPANY 테이블에서 업데이트 된 레코드를 가져와 표시하는 방법을 보여줍니다.

#!/usr/bin/perl

use DBI;
use strict;

my $driver = "SQLite"; my $database = "test.db";
my $dsn = "DBI:$driver:dbname=$database"; my $userid = "";
my $password = ""; my $dbh = DBI->connect($dsn, $userid, $password, { RaiseError => 1 }) or die $DBI::errstr;
print "Opened database successfully\n";

my $stmt = qq(UPDATE COMPANY set SALARY = 25000.00 where ID=1;); my $rv = $dbh->do($stmt) or die $DBI::errstr; if( $rv < 0 ) {
   print $DBI::errstr; } else { print "Total number of rows updated : $rv\n";
}
$stmt = qq(SELECT id, name, address, salary from COMPANY;); my $sth = $dbh->prepare( $stmt );
$rv = $sth->execute() or die $DBI::errstr; if($rv < 0) {
   print $DBI::errstr; } while(my @row = $sth->fetchrow_array()) {
      print "ID = ". $row[0] . "\n"; print "NAME = ". $row[1] ."\n";
      print "ADDRESS = ". $row[2] ."\n"; print "SALARY = ". $row[3] ."\n\n";
}
print "Operation done successfully\n";
$dbh->disconnect();

위 프로그램을 실행하면 다음과 같은 결과가 나옵니다.

Opened database successfully
Total number of rows updated : 1
ID = 1
NAME = Paul
ADDRESS = California
SALARY =  25000

ID = 2
NAME = Allen
ADDRESS = Texas
SALARY =  15000

ID = 3
NAME = Teddy
ADDRESS = Norway
SALARY =  20000

ID = 4
NAME = Mark
ADDRESS = Rich-Mond
SALARY =  65000

Operation done successfully

작업 삭제

다음 Perl 코드는 DELETE 문을 사용하여 레코드를 삭제 한 다음 COMPANY 테이블에서 나머지 레코드를 가져와 표시하는 방법을 보여줍니다.

#!/usr/bin/perl

use DBI;
use strict;

my $driver   = "SQLite";
my $database = "test.db"; my $dsn = "DBI:$driver:dbname=$database";
my $userid = ""; my $password = "";
my $dbh = DBI->connect($dsn, $userid, $password, { RaiseError => 1 })
   or die $DBI::errstr; print "Opened database successfully\n"; my $stmt = qq(DELETE from COMPANY where ID = 2;);
my $rv = $dbh->do($stmt) or die $DBI::errstr;

if( $rv < 0 ) { print $DBI::errstr;
} else {
   print "Total number of rows deleted : $rv\n"; } $stmt = qq(SELECT id, name, address, salary from COMPANY;);
my $sth = $dbh->prepare( $stmt ); $rv = $sth->execute() or die $DBI::errstr;

if($rv < 0) { print $DBI::errstr;
}

while(my @row = $sth->fetchrow_array()) { print "ID = ". $row[0] . "\n";
      print "NAME = ". $row[1] ."\n"; print "ADDRESS = ". $row[2] ."\n";
      print "SALARY =  ". $row[3] ."\n\n"; } print "Operation done successfully\n"; $dbh->disconnect();

위 프로그램을 실행하면 다음과 같은 결과가 나옵니다.

Opened database successfully
Total number of rows deleted : 1
ID = 1
NAME = Paul
ADDRESS = California
SALARY = 25000

ID = 3
NAME = Teddy
ADDRESS = Norway
SALARY = 20000

ID = 4
NAME = Mark
ADDRESS = Rich-Mond
SALARY = 65000

Operation done successfully

이 장에서는 Python 프로그램에서 SQLite를 사용하는 방법을 배웁니다.

설치

SQLite3는 Gerhard Haring이 작성한 sqlite3 모듈을 사용하여 Python과 통합 할 수 있습니다. PEP 249에 설명 된 DB-API 2.0 사양을 준수하는 SQL 인터페이스를 제공합니다.이 모듈은 기본적으로 Python 버전 2.5.x와 함께 제공되므로 별도로 설치할 필요가 없습니다.

sqlite3 모듈을 사용하려면 먼저 데이터베이스를 나타내는 연결 개체를 만든 다음 선택적으로 모든 SQL 문을 실행하는 데 도움이되는 커서 개체를 만들 수 있습니다.

Python sqlite3 모듈 API

다음은 중요한 sqlite3 모듈 루틴으로, Python 프로그램에서 SQLite 데이터베이스로 작업하기위한 요구 사항을 충족 할 수 있습니다. 더 정교한 애플리케이션을 찾고 있다면 Python sqlite3 모듈의 공식 문서를 살펴볼 수 있습니다.

Sr. 아니. API 및 설명
1

sqlite3.connect(database [,timeout ,other optional arguments])

이 API는 SQLite 데이터베이스 파일에 대한 연결을 엽니 다. ": memory :"를 사용하여 디스크 대신 RAM에있는 데이터베이스에 대한 데이터베이스 연결을 열 수 있습니다. 데이터베이스가 성공적으로 열리면 연결 개체를 반환합니다.

여러 연결로 데이터베이스에 액세스하고 프로세스 중 하나가 데이터베이스를 수정하면 해당 트랜잭션이 커밋 될 때까지 SQLite 데이터베이스가 잠 깁니다. timeout 매개 변수는 예외가 발생할 때까지 잠금이 사라질 때까지 연결이 대기해야하는 시간을 지정합니다. 제한 시간 매개 변수의 기본값은 5.0 (5 초)입니다.

주어진 데이터베이스 이름이 존재하지 않는 경우이 호출은 데이터베이스를 생성합니다. 현재 디렉토리를 제외한 다른 곳에서 데이터베이스를 생성하려는 경우에도 필요한 경로와 함께 파일 이름을 지정할 수 있습니다.
2

connection.cursor([cursorClass])

이 루틴은 cursor이것은 Python으로 데이터베이스 프로그래밍 전반에 걸쳐 사용됩니다. 이 메소드는 단일 선택적 매개 변수 cursorClass를 허용합니다. 제공된 경우 sqlite3.Cursor를 확장하는 사용자 정의 커서 클래스 여야합니다.
삼

cursor.execute(sql [, optional parameters])

이 루틴은 SQL 문을 실행합니다. SQL 문은 매개 변수화 될 수 있습니다 (즉, SQL 리터럴 대신 자리 표시 자). sqlite3 모듈은 물음표와 명명 된 플레이스 홀더 (스타일 명)라는 두 가지 종류의 플레이스 홀더를 지원합니다.

For example − cursor.execute ( "사람 값에 삽입 (?,?)", (누가, 나이))
4

connection.execute(sql [, optional parameters])

이 루틴은 커서 개체가 제공하는 위의 실행 메서드의 바로 가기이며 커서 메서드를 호출하여 중간 커서 개체를 만든 다음 주어진 매개 변수로 커서의 실행 메서드를 호출합니다.
5

cursor.executemany(sql, seq_of_parameters)

이 루틴은 시퀀스 sql에서 찾은 모든 매개 변수 시퀀스 또는 매핑에 대해 SQL 명령을 실행합니다.
6

connection.executemany(sql[, parameters])

이 루틴은 커서 메서드를 호출하여 중간 커서 개체를 만든 다음 주어진 매개 변수로 cursor.s executemany 메서드를 호출하는 바로 가기입니다.
7

cursor.executescript(sql_script)

이 루틴은 스크립트 형식으로 제공된 여러 SQL 문을 한 번에 실행합니다. 먼저 COMMIT 문을 발행 한 다음 매개 변수로 가져 오는 SQL 스크립트를 실행합니다. 모든 SQL 문은 세미콜론 (;)으로 구분해야합니다.
8

connection.executescript(sql_script)

이 루틴은 커서 메서드를 호출하여 중간 커서 개체를 만든 다음 지정된 매개 변수로 커서의 executescript 메서드를 호출하는 바로 가기입니다.
9

connection.total_changes()

이 루틴은 데이터베이스 연결이 열린 이후 수정, 삽입 또는 삭제 된 총 데이터베이스 행 수를 리턴합니다.
10

connection.commit()

이 메서드는 현재 트랜잭션을 커밋합니다. 이 메서드를 호출하지 않으면 마지막 commit () 호출 이후에 수행 한 작업이 다른 데이터베이스 연결에서 표시되지 않습니다.
11

connection.rollback()

이 메서드는 commit ()에 대한 마지막 호출 이후 데이터베이스에 대한 모든 변경 사항을 롤백합니다.
12

connection.close()

이 방법은 데이터베이스 연결을 닫습니다. 이것은 commit ()을 자동으로 호출하지 않습니다. commit ()을 먼저 호출하지 않고 데이터베이스 연결을 닫으면 변경 사항이 손실됩니다!
13

cursor.fetchone()

이 메서드는 쿼리 결과 집합의 다음 행을 가져 와서 단일 시퀀스를 반환하거나 더 이상 데이터를 사용할 수없는 경우 없음을 반환합니다.
14

cursor.fetchmany([size = cursor.arraysize])

이 루틴은 쿼리 결과의 다음 행 집합을 가져와 목록을 반환합니다. 사용 가능한 행이 더 이상 없으면 빈 목록이 반환됩니다. 메소드는 size 매개 변수에 표시된만큼의 행을 가져 오려고합니다.
15

cursor.fetchall()

이 루틴은 쿼리 결과의 모든 (나머지) 행을 가져 와서 목록을 반환합니다. 사용 가능한 행이 없으면 빈 목록이 반환됩니다.

데이터베이스에 연결

다음 Python 코드는 기존 데이터베이스에 연결하는 방법을 보여줍니다. 데이터베이스가 존재하지 않으면 생성되고 마지막으로 데이터베이스 개체가 반환됩니다.

#!/usr/bin/python

import sqlite3

conn = sqlite3.connect('test.db')

print "Opened database successfully";

여기에서 데이터베이스 이름을 특수 이름으로 제공 할 수도 있습니다. :memory:RAM에 데이터베이스를 만듭니다. 이제 위의 프로그램을 실행하여 데이터베이스를 생성하겠습니다.test.db현재 디렉토리에서. 요구 사항에 따라 경로를 변경할 수 있습니다. 위 코드를 sqlite.py 파일에 보관하고 아래와 같이 실행합니다. 데이터베이스가 성공적으로 생성되면 다음 메시지가 표시됩니다.

$chmod +x sqlite.py $./sqlite.py
Open database successfully

테이블 생성

다음 Python 프로그램은 이전에 생성 된 데이터베이스에 테이블을 생성하는 데 사용됩니다.

#!/usr/bin/python

import sqlite3

conn = sqlite3.connect('test.db')
print "Opened database successfully";

conn.execute('''CREATE TABLE COMPANY
         (ID INT PRIMARY KEY     NOT NULL,
         NAME           TEXT    NOT NULL,
         AGE            INT     NOT NULL,
         ADDRESS        CHAR(50),
         SALARY         REAL);''')
print "Table created successfully";

conn.close()

위의 프로그램이 실행되면 COMPANY 테이블이 생성됩니다. test.db 다음 메시지가 표시됩니다.

Opened database successfully
Table created successfully

INSERT 작업

다음 Python 프로그램은 위의 예에서 생성 된 COMPANY 테이블에 레코드를 생성하는 방법을 보여줍니다.

#!/usr/bin/python

import sqlite3

conn = sqlite3.connect('test.db')
print "Opened database successfully";

conn.execute("INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY) \
      VALUES (1, 'Paul', 32, 'California', 20000.00 )");

conn.execute("INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY) \
      VALUES (2, 'Allen', 25, 'Texas', 15000.00 )");

conn.execute("INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY) \
      VALUES (3, 'Teddy', 23, 'Norway', 20000.00 )");

conn.execute("INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY) \
      VALUES (4, 'Mark', 25, 'Rich-Mond ', 65000.00 )");

conn.commit()
print "Records created successfully";
conn.close()

위의 프로그램이 실행되면 COMPANY 테이블에 주어진 레코드를 생성하고 다음 두 줄을 표시합니다.

Opened database successfully
Records created successfully

SELECT 작업

다음 Python 프로그램은 위의 예에서 만든 COMPANY 테이블에서 레코드를 가져 와서 표시하는 방법을 보여줍니다.

#!/usr/bin/python

import sqlite3

conn = sqlite3.connect('test.db')
print "Opened database successfully";

cursor = conn.execute("SELECT id, name, address, salary from COMPANY")
for row in cursor:
   print "ID = ", row[0]
   print "NAME = ", row[1]
   print "ADDRESS = ", row[2]
   print "SALARY = ", row[3], "\n"

print "Operation done successfully";
conn.close()

위 프로그램을 실행하면 다음과 같은 결과가 나옵니다.

Opened database successfully
ID = 1
NAME = Paul
ADDRESS = California
SALARY = 20000.0

ID = 2
NAME = Allen
ADDRESS = Texas
SALARY = 15000.0

ID = 3
NAME = Teddy
ADDRESS = Norway
SALARY = 20000.0

ID = 4
NAME = Mark
ADDRESS = Rich-Mond
SALARY = 65000.0

Operation done successfully

업데이트 작업

다음 Python 코드는 UPDATE 문을 사용하여 레코드를 업데이트 한 다음 COMPANY 테이블에서 업데이트 된 레코드를 가져와 표시하는 방법을 보여줍니다.

#!/usr/bin/python

import sqlite3

conn = sqlite3.connect('test.db')
print "Opened database successfully";

conn.execute("UPDATE COMPANY set SALARY = 25000.00 where ID = 1")
conn.commit()
print "Total number of rows updated :", conn.total_changes

cursor = conn.execute("SELECT id, name, address, salary from COMPANY")
for row in cursor:
   print "ID = ", row[0]
   print "NAME = ", row[1]
   print "ADDRESS = ", row[2]
   print "SALARY = ", row[3], "\n"

print "Operation done successfully";
conn.close()

위 프로그램을 실행하면 다음과 같은 결과가 나옵니다.

Opened database successfully
Total number of rows updated : 1
ID = 1
NAME = Paul
ADDRESS = California
SALARY = 25000.0

ID = 2
NAME = Allen
ADDRESS = Texas
SALARY = 15000.0

ID = 3
NAME = Teddy
ADDRESS = Norway
SALARY = 20000.0

ID = 4
NAME = Mark
ADDRESS = Rich-Mond
SALARY = 65000.0

Operation done successfully

작업 삭제

다음 Python 코드는 DELETE 문을 사용하여 레코드를 삭제 한 다음 COMPANY 테이블에서 나머지 레코드를 가져와 표시하는 방법을 보여줍니다.

#!/usr/bin/python

import sqlite3

conn = sqlite3.connect('test.db')
print "Opened database successfully";

conn.execute("DELETE from COMPANY where ID = 2;")
conn.commit()
print "Total number of rows deleted :", conn.total_changes

cursor = conn.execute("SELECT id, name, address, salary from COMPANY")
for row in cursor:
   print "ID = ", row[0]
   print "NAME = ", row[1]
   print "ADDRESS = ", row[2]
   print "SALARY = ", row[3], "\n"

print "Operation done successfully";
conn.close()

위 프로그램을 실행하면 다음과 같은 결과가 나옵니다.

Opened database successfully
Total number of rows deleted : 1
ID = 1
NAME = Paul
ADDRESS = California
SALARY = 20000.0

ID = 3
NAME = Teddy
ADDRESS = Norway
SALARY = 20000.0

ID = 4
NAME = Mark
ADDRESS = Rich-Mond
SALARY = 65000.0

Operation done successfully
ja/tutorial
es/tutorial
de/tutorial
fr/tutorial
th/tutorial
pt/tutorial
ru/tutorial
vi/tutorial
it/tutorial
ko/tutorial
tr/tutorial
id/tutorial
pl/tutorial
hi/tutorial
japost
espost
depost
frpost
thpost
ptpost
rupost
vipost
itpost
kopost
trpost
idpost
plpost
hipost

© Copyright 2021 - 2024 | All Rights Reserved