シーケンスとは｜IT用語の意味を分野別に解説・DBの連番を実演

どの分野の「シーケンス」も、根っこは「順番」です。何の順番を扱うかで、指すものが分かれます。

flowchart LR
    S[シーケンス<br>順番に並んだもの] --> D[DBの連番<br>1, 2, 3 と番号を配る]
    S --> Z[シーケンス図<br>やり取りの順番を描く]
    S --> J[順次処理<br>上から順に実行]
    S --> P[Pythonのシーケンス型<br>list・tuple・str]
    S --> C[シーケンス制御<br>機械を決めた順に動かす]

急いでいる人向けに、よく調べられることの答えを先にまとめます。

確認環境：Ubuntu 24.04.4 LTS。データベースの連番は、apt の PostgreSQL 16.15（psql と psycopg 3.3.6 で2つのセッションを同時に開いて確かめた）、MySQL 8.0.46（InnoDB）、SQLite 3.45.1 で、作成・採番・ロールバック・CACHE・setval・再起動後の続きを実際に動かしました。試験用のデータベース s386db は終わったあと削除しました。Python のシーケンス型・順次処理・シーケンス制御の考え方は Python 3.11.15 で実行し、TCP のシーケンス番号は tcpdump 4.99.4 と curl 8.5.0 で見ています。仕様は PostgreSQL・MySQL・SQLite・Oracle Database・SQL Server・Python の公式ドキュメントと RFC 9293 で確かめました（確認日 2026年10月23日）。

シーケンスとは（意味と分野別の見分け方）

この節では、「シーケンス」という言葉のもとの意味と、場面ごとに何を指しているかの見分け方が分かります。

シーケンス（sequence）は、英語で「連続・順序・並び」という意味の言葉です。 小学館のデジタル大辞泉は「連続。連続して起こる順序」を最初の意味に挙げ、映画のひと続きのシーン、機器を自動制御するときの動作の順序なども載せています。「シークエンス」と書くこともあります。

IT では、何の順番を扱うかで指すものが変わります。

IT 以外では、映画・映像の「ひと続きの場面のまとまり」、音楽の「シーケンサー（演奏の順番を記録して自動で鳴らす機械やソフト）」、カリキュラムの「学ぶ順序（スコープとシーケンス）」、トランプの「同じ種類で数が続く札のそろい」、地学の「地層の重なり」にも使われます。SNS の動画編集の機能名として紹介されることもあります。どれも「順番に並ぶ・つながる」という同じ意味から来ています。

IT の会話で単に「シーケンス」と言うときは、データベースの連番を指していることがいちばん多い言葉です。 この記事でもデータベースのシーケンスを中心に実物で説明し、ほかの意味は後半の節で見分けます。

データベースのシーケンスとは（連番を自動で配る仕組み）

この節では、データベースのシーケンスが何をするもので、どう作って番号を取り出すのかが、PostgreSQL 16 の実物で分かります。

データベースのシーケンスは、呼ぶたびに重複しない次の番号を返す「番号札の発券機」です。 銀行の窓口の番号札と同じで、だれかが札を取ると数字が1つ進み、同じ番号が2人に渡ることはありません。PostgreSQL のドキュメントも、nextval は複数のセッションが同時に呼んでも、それぞれに別の値を安全に返す、と説明しています。

CREATE SEQUENCE と nextval・currval

PostgreSQL 16 で、注文番号用のシーケンスを作って番号を取り出しました。

CREATE SEQUENCE order_no_seq;
SELECT nextval('order_no_seq');
SELECT nextval('order_no_seq');
SELECT currval('order_no_seq');
SELECT * FROM pg_sequences WHERE sequencename = 'order_no_seq';

 nextval 
---------
       1
(1 row)

 nextval 
---------
       2
(1 row)

 currval 
---------
       2
(1 row)

-[ RECORD 1 ]-+--------------------
schemaname    | public
sequencename  | order_no_seq
sequenceowner | postgres
data_type     | bigint
start_value   | 1
min_value     | 1
max_value     | 9223372036854775807
increment_by  | 1
cycle         | f
cache_size    | 1
last_value    | 2

何も指定しないと、bigint 型で1から1ずつ増え、CACHE は1でした。 pg_sequences ビューで、どのシーケンスがどこまで進んでいるか（last_value）を一覧で見られます。

開始値と増分を変えると、請求書番号のような形も作れます。

CREATE SEQUENCE inv_seq START WITH 1000 INCREMENT BY 10;
SELECT nextval('inv_seq'), nextval('inv_seq'), nextval('inv_seq');
SELECT 'INV-' || to_char(nextval('inv_seq'), 'FM000000') AS invoice_no;

 nextval | nextval | nextval 
---------+---------+---------
    1000 |    1010 |    1020
(1 row)

 invoice_no 
------------
 INV-001030
(1 row)

currval は「このセッションで最後に取った番号」なので、そのセッションでまだ nextval を呼んでいないとエラーになります。

=> CREATE SEQUENCE fresh_seq;
=> SELECT currval('fresh_seq');
ERROR:  currval of sequence "fresh_seq" is not yet defined in this session

CREATE SEQUENCE の主なオプションと既定値です（PostgreSQL 16 のドキュメントで確認）。

IDENTITY 列と serial（表の id に使う方法）

ふだんはシーケンスを手で呼ばず、表の id 列に自動でつながる形で使います。PostgreSQL では GENERATED … AS IDENTITY が SQL 標準の書き方で、以前からある serial も使えます。

CREATE TABLE orders (
  id   bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
  item text NOT NULL
);
INSERT INTO orders (item) VALUES ('りんご') RETURNING id;
SELECT pg_get_serial_sequence('orders', 'id');

CREATE TABLE users_old (id serial PRIMARY KEY, name text);
\d users_old

 id 
----
  1
(1 row)

 pg_get_serial_sequence 
------------------------
 public.orders_id_seq
(1 row)

 Column |  Type   | Collation | Nullable |                Default                
--------+---------+-----------+----------+---------------------------------------
 id     | integer |           | not null | nextval('users_old_id_seq'::regclass)

IDENTITY 列にも serial にも、裏で 表名_列名_seq というシーケンスが作られていました。 serial は「列の既定値に nextval を書く」短い書き方で、\d で見ると既定値の欄に nextval('users_old_id_seq'::regclass) が出ます。

GENERATED ALWAYS の列に番号を手で入れると、エラーで止まります。

=> INSERT INTO orders (id, item) VALUES (100, 'なし');
ERROR:  cannot insert a non-DEFAULT value into column "id"
DETAIL:  Column "id" is an identity column defined as GENERATED ALWAYS.
HINT:  Use OVERRIDING SYSTEM VALUE to override.

serial と IDENTITY の違いと移行の手順は、関連記事「PostgreSQL連番｜serialとIDENTITYの違いとsetval修正」で扱っています。

シーケンスの番号が飛ぶ理由（ロールバック・エラー・ON CONFLICT）

この節では、「連番なのに番号が飛ぶ」のがなぜ起きるのかと、それが仕様であることが、実物で分かります。

シーケンスの番号は、トランザクションをロールバックしても戻りません。 上の orders 表で、ロールバック・NOT NULL 違反のエラーをはさんで追加しました。

INSERT INTO orders (item) VALUES ('りんご') RETURNING id;   -- 1
BEGIN;
INSERT INTO orders (item) VALUES ('みかん') RETURNING id;   -- 2
ROLLBACK;
INSERT INTO orders (item) VALUES ('ぶどう') RETURNING id;   -- 3
INSERT INTO orders (item) VALUES (NULL);                    -- エラー
INSERT INTO orders (item) VALUES ('もも') RETURNING id;
SELECT * FROM orders ORDER BY id;

ERROR:  null value in column "item" of relation "orders" violates not-null constraint
DETAIL:  Failing row contains (4, null).

 id 
----
  5
(1 row)

 id |  item  
----+--------
  1 | りんご
  3 | ぶどう
  5 | もも
(3 rows)

ロールバックした2番と、エラーになった4番が欠番になりました。 エラーの DETAIL に (4, null) と出ているとおり、行を作る前に番号を取ってから失敗しています。

INSERT … ON CONFLICT DO NOTHING でも番号が消費されます。メールアドレスが重複して何も入らなかった次の追加で、5 を飛ばして 6 になりました。

=> INSERT INTO members (email) VALUES ('d@example.com') ON CONFLICT (email) DO NOTHING RETURNING id;
 id 
----
(0 rows)

=> INSERT INTO members (email) VALUES ('e@example.com') RETURNING id;
 id 
----
  6
(1 row)

flowchart TD
    A[INSERT が nextval を呼ぶ<br>番号 2 を取る] --> B{このあと}
    B -->|COMMIT| C[2 が表に残る]
    B -->|ROLLBACK・エラー| D[行は消える<br>番号 2 は戻らない]
    D --> E[次の INSERT は 3<br>2 は欠番]

PostgreSQL のドキュメントは、同じシーケンスから番号を取るトランザクションどうしが待たないように、取り消されたトランザクションの番号は再利用しない、と説明しています。そのため「欠番の無い（gapless）連番」にはシーケンスを使えない、と明記しています。番号が飛ぶのは故障ではなく、速く・同時に配るための仕様です。

CACHE の動き（セッションごとに番号を先取りする）

この節では、CACHE を大きくすると番号の順番と欠番がどう変わるかが、2つのセッションを交互に動かした実物で分かります。

CACHE は、セッションが番号を一度にまとめて確保しておく個数です。 CACHE 10 なら、最初に nextval を呼んだセッションが 1〜10 をまとめて確保し、その後はシーケンスに触れずに手元の番号を返します。

Python（psycopg 3）で、CACHE 1 と CACHE 10 のシーケンスに、セッション A と B から交互に nextval を呼びました。

import psycopg

DSN = "dbname=s386db user=postgres host=/var/run/postgresql"
admin = psycopg.connect(DSN, autocommit=True)
admin.execute("CREATE SEQUENCE c1_seq")             # CACHE 1（既定）
admin.execute("CREATE SEQUENCE c10_seq CACHE 10")   # 10個ずつ先取り

def nv(conn, seq):
    return conn.execute(f"SELECT nextval('{seq}')").fetchone()[0]

for seq in ("c1_seq", "c10_seq"):
    a = psycopg.connect(DSN, autocommit=True)   # セッションA
    b = psycopg.connect(DSN, autocommit=True)   # セッションB
    order = [("A", a), ("B", b), ("A", a), ("B", b), ("A", a)]
    got = [f"{name}={nv(c, seq)}" for name, c in order]
    last = admin.execute(f"SELECT last_value FROM {seq}").fetchone()[0]
    print(f"{seq}: {' '.join(got)}  last_value={last}")
    a.close(); b.close()                          # セッションを閉じる
    c = psycopg.connect(DSN, autocommit=True)     # 新しいセッション
    print(f"  閉じたあと新しいセッションの nextval = {nv(c, seq)}")
    c.close()

c1_seq: A=1 B=2 A=3 B=4 A=5  last_value=5
  閉じたあと新しいセッションの nextval = 6
c10_seq: A=1 B=11 A=2 B=12 A=3  last_value=20
  閉じたあと新しいセッションの nextval = 21

CACHE 10 では、A と B が 1, 11, 2, 12, 3 と順番の入り混じった番号を受け取り、セッションを閉じると使わなかった番号が捨てられて、次は 21 から始まりました。 PostgreSQL のドキュメントどおり、CACHE が1より大きいときは「番号はすべて別々」だけが保証され、「取った順に小さい」とは限りません。last_value もまだ返していない確保分まで進みます。

番号の大小で登録順を判断する処理があるなら CACHE は1のまま、大量に追加するバッチで速さが要るなら CACHE を増やす、という判断になります。登録順には作成日時の列を別に持つと、CACHE の値に左右されません。

ずれたシーケンスを setval で直す（duplicate key の直し方）

この節では、シーケンスが表の最大値より遅れて duplicate key が出る状況を再現し、setval で直す手順が分かります。

データの移行や手での INSERT で id を直接入れると、シーケンスは進まず、次の自動の番号が既存の行とぶつかります。 GENERATED BY DEFAULT の表に id 1〜3 を手で入れてから、自動の番号で追加しました。

CREATE TABLE members (id integer GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY, email text UNIQUE);
INSERT INTO members (id, email) VALUES (1, 'a@example.com'), (2, 'b@example.com'), (3, 'c@example.com');
INSERT INTO members (email) VALUES ('d@example.com');
SELECT last_value, is_called FROM members_id_seq;
SELECT max(id) FROM members;

ERROR:  duplicate key value violates unique constraint "members_pkey"
DETAIL:  Key (id)=(1) already exists.

 last_value | is_called 
------------+-----------
          1 | t
(1 row)

 max 
-----
   3
(1 row)

表には 3 まで入っているのに、シーケンスは 1 を配ったところでした。 シーケンスを表の最大値に合わせます。

SELECT setval(pg_get_serial_sequence('members', 'id'), (SELECT max(id) FROM members));
INSERT INTO members (email) VALUES ('d@example.com') RETURNING id;

 setval 
--------
      3
(1 row)

 id 
----
  4
(1 row)

setval(シーケンス, 値) は「その値まで配り終えた」状態にするので、次は 4 になりました。3つ目の引数に false を付けると「次にその値を配る」状態になります。

表が空のときに max(id) を使うと NULL になり、setval は何もせず NULL を返しました。空の表でも使える形にするには、COALESCE と3つ目の引数 false を組み合わせます。

SELECT setval(pg_get_serial_sequence('members', 'id'),
              COALESCE((SELECT max(id) FROM members), 0) + 1, false);

 setval 
--------
      1
(1 row)

ずれている表を一度に探すには、シーケンスにつながる列ごとに、表の最大値とシーケンスの last_value を並べます。psql の \gexec で、作った SELECT 文をそのまま実行しました。

SELECT 'SELECT ' || quote_literal(c.table_name) || ' AS tbl, (SELECT max(' || quote_ident(c.column_name)
    || ') FROM ' || quote_ident(c.table_schema) || '.' || quote_ident(c.table_name) || ') AS max_id, (SELECT last_value FROM '
    || pg_get_serial_sequence(quote_ident(c.table_schema) || '.' || quote_ident(c.table_name), c.column_name) || ') AS seq_last'
FROM information_schema.columns c
WHERE c.table_schema = 'public'
  AND pg_get_serial_sequence(quote_ident(c.table_schema) || '.' || quote_ident(c.table_name), c.column_name) IS NOT NULL
\gexec

   tbl   | max_id | seq_last 
---------+--------+----------
 members |    500 |      500
(1 row)

  tbl   | max_id | seq_last 
--------+--------+----------
 orders |    100 |        5
(1 row)

orders は表の最大値 100 に対してシーケンスが 5 で、このまま追加を続けると 100 番でぶつかります。 前の節で OVERRIDING SYSTEM VALUE を使って 100 を手で入れたためです。setval で 100 に合わせると、次の追加は 101 になりました。

ほかの戻し方と、それぞれの結果です。

setval もロールバックでは戻りません。BEGIN のあと setval('order_no_seq', 9000) を実行して ROLLBACK しても、次の nextval は 9001 でした。ドキュメントにも、setval の変更はほかのトランザクションからすぐ見え、ロールバックで取り消されない、と書かれています。本番で直すときは、対象の表と値を確かめてから1回だけ実行します。

エラー文から原因を切り分ける手順は、関連記事「PostgreSQL duplicate keyの直し方｜シーケンスのずれ」で扱っています。

上限に達したとき（MAXVALUE と CYCLE）

この節では、シーケンスが上限まで進んだときに何が起きるかが分かります。

型を smallint、上限を 3 にして試しました。

=> CREATE SEQUENCE tiny_seq AS smallint MAXVALUE 3;
=> SELECT nextval('tiny_seq'), nextval('tiny_seq'), nextval('tiny_seq');
 nextval | nextval | nextval 
---------+---------+---------
       1 |       2 |       3

=> SELECT nextval('tiny_seq');
ERROR:  nextval: reached maximum value of sequence "tiny_seq" (3)

=> CREATE SEQUENCE cyc_seq MAXVALUE 3 CYCLE;
=> SELECT nextval('cyc_seq') FROM generate_series(1,5);
 nextval 
---------
       1
       2
       3
       1
       2

NO CYCLE（既定）では上限でエラーになり、CYCLE では 1 に戻りました。 主キーに使うシーケンスで CYCLE を付けると、戻った番号が既存の行とぶつかります。表の id は bigint にしておくと、上限（約922京）に届く心配はほぼありません。integer の列（上限 2,147,483,647）で上限に近づいたときの直し方は、列の型を bigint に変えることです。

MySQL・SQLite・Oracle・SQL Server の連番の違い

この節では、データベース製品ごとに連番の作り方と「飛ぶ・戻る」のふるまいがどう違うかが、実物と公式ドキュメントで分かります。

MySQL 8.0 の AUTO_INCREMENT

MySQL 8.0 には CREATE SEQUENCE がなく、連番は列の AUTO_INCREMENT で作ります。 CREATE SEQUENCE を実行すると構文エラーになりました。

mysql> CREATE SEQUENCE s1;
ERROR 1064 (42000): You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'SEQUENCE s1' at line 1

PostgreSQL と同じ手順で、ロールバック・手での番号の指定・カウンターの変更・再起動を試しました。

SELECT @@innodb_autoinc_lock_mode;           -- 2
CREATE TABLE orders (id BIGINT AUTO_INCREMENT PRIMARY KEY, item VARCHAR(20) NOT NULL);
INSERT INTO orders (item) VALUES ('りんご');  -- 1
START TRANSACTION;
INSERT INTO orders (item) VALUES ('みかん');  -- 2
ROLLBACK;
INSERT INTO orders (item) VALUES ('ぶどう');  -- 3
INSERT INTO orders (id, item) VALUES (100, 'なし');
INSERT INTO orders (item) VALUES ('もも');    -- 101
ALTER TABLE orders AUTO_INCREMENT = 10;       -- 最大値より小さい値
INSERT INTO orders (item) VALUES ('かき');    -- 102

+-----+-----------+
| id  | item      |
+-----+-----------+
|   1 | りんご |
|   3 | ぶどう |
| 100 | なし    |
| 101 | もも    |
| 102 | かき    |
+-----+-----------+

• ロールバックした 2 は欠番になりました。MySQL のドキュメントも、どのロックモードでもロールバックした番号は失われ再利用されない、と説明しています。
• id を 100 と手で入れると、次の自動の番号は 101 に進みました。PostgreSQL のようにぶつかることはありません。
• AUTO_INCREMENT = 10 のように使用中の最大値以下を指定しても、102 から続きました。
• 101・102 を消して MySQL を再起動してから追加すると、103 でした。MySQL 8.0 からカウンターの値が再起動をまたいで保たれます（5.7 までは再起動後に最大値から数え直していた、とドキュメントにあります）。

MySQL 8.0 の既定のロックモードは innodb_autoinc_lock_mode=2（interleaved）で、手元でも 2 でした。リセットや確認の SQL は、関連記事「MySQL AUTO_INCREMENTのリセット・確認・変更方法【コピペ用SQL】」で扱っています。

SQLite の ROWID と AUTOINCREMENT

SQLite では INTEGER PRIMARY KEY の列が自動で番号を持ち、AUTOINCREMENT を付けるかどうかで、消した番号を再利用するかが変わります。

CREATE TABLE a (id INTEGER PRIMARY KEY, item TEXT);
CREATE TABLE b (id INTEGER PRIMARY KEY AUTOINCREMENT, item TEXT);
INSERT INTO a (item) VALUES ('x'),('y'),('z');
INSERT INTO b (item) VALUES ('x'),('y'),('z');
DELETE FROM a WHERE id = 3;
DELETE FROM b WHERE id = 3;
INSERT INTO a (item) VALUES ('new');
INSERT INTO b (item) VALUES ('new');
SELECT 'a' AS tbl, id, item FROM a UNION ALL SELECT 'b', id, item FROM b;
SELECT * FROM sqlite_sequence;
BEGIN;
INSERT INTO b (item) VALUES ('rollback');
ROLLBACK;
INSERT INTO b (item) VALUES ('after');
SELECT id, item FROM b;

tbl  id  item
---  --  ----
a    1   x   
a    2   y   
a    3   new 
b    1   x   
b    2   y   
b    4   new 
name  seq
----  ---
b     4  
id  item 
--  -----
1   x    
2   y    
4   new  
5   after

AUTOINCREMENT なしの表 a は消した 3 を再利用し、AUTOINCREMENT ありの表 b は 4 に進みました。 一方、表 b でロールバックした番号は欠番にならず、次は 5 でした。SQLite は最大の番号を sqlite_sequence という普通の表に記録しているため、その更新もロールバックで元に戻ります。SQLite のドキュメントは、AUTOINCREMENT は CPU・メモリ・ディスクの負担が増えるので、必要でなければ避けるよう勧めています。

製品ごとの比較

Oracle のドキュメントは、障害が起きるとキャッシュした番号のうち使われていないものが失われ、失われる数は最大で CACHE の値になる、と説明しています。SQL Server のドキュメントも、シーケンス番号は現在のトランザクションの範囲外で生成され、コミットかロールバックかに関係なく使われる、と説明しています。SQL Server のシーケンスは、型を指定しないと bigint になります。

番号を飛ばしたくないとき（採番テーブルとの違い）

この節では、請求書番号のように欠番を許さない番号をどう作るかと、シーケンスとの違いが分かります。

欠番の無い番号が要るときは、シーケンスではなく「最後の番号を1行で持つ表（採番テーブル）」を UPDATE して番号を取ります。 表の更新はロールバックで元に戻るので、欠番が出ません。

CREATE TABLE invoice_counter (year int PRIMARY KEY, last_no int NOT NULL);
INSERT INTO invoice_counter VALUES (2026, 0);
BEGIN;
UPDATE invoice_counter SET last_no = last_no + 1 WHERE year = 2026 RETURNING last_no;  -- 1
ROLLBACK;
BEGIN;
UPDATE invoice_counter SET last_no = last_no + 1 WHERE year = 2026 RETURNING last_no;  -- また 1
COMMIT;

ただし、同じ行を更新するので、前のトランザクションが終わるまで次の人は待たされます。セッション A が番号を取って COMMIT する前に、セッション B がシーケンスと採番テーブルの両方から番号を取りました。

 0.0s A: 2 を取得（COMMIT前）
 0.0s A: nextval = 9002
 0.0s B: nextval = 9003（待たずに返る）
 0.0s B: カウンター表を更新しようとする…
 2.0s A: COMMIT
 2.0s B: 3 を取得

ID の主キーにはシーケンス、法令や業務で連続性を求められる帳票番号には採番テーブル、と使い分けます。UUID を含めた採番の方式の比較は、関連記事「採番設計の方法｜シーケンス・採番テーブル・UUIDの比較表とSQL例」で扱っています。

プログラミングの「順次」とは（順次・分岐・反復）

この節では、プログラムの基本の形の1つ「順次（シーケンス）」が何で、分岐・反復とどう組み合わさるかが分かります。

どんなプログラムも「順次・分岐・反復」の3つの形の組み合わせで書けます。 これを構造化プログラミングの3つの基本構造と呼び、英語では順次を sequence、分岐を selection、反復を iteration（repetition）と言います。

flowchart TD
    A[値段を並べる] --> B[合計を 0 にする]
    B --> C{まだ値段が残っている}
    C -->|はい 反復| D[合計に足す]
    D --> C
    C -->|いいえ| E{合計が 1000 円以上}
    E -->|はい 分岐| F[送料 0 円]
    E -->|いいえ| G[送料 500 円]

この図のとおりに Python で書いて実行しました。

# 順次・分岐・反復：買い物かごの合計を出す
prices = [120, 980, 300]          # 順次：上から1行ずつ実行される
total = 0
for p in prices:                  # 反復：同じ処理を要素の数だけ繰り返す
    total += p
if total >= 1000:                 # 分岐：条件で道が分かれる
    shipping = 0
else:
    shipping = 500
print("合計", total, "円 / 送料", shipping, "円 / 支払い", total + shipping, "円")

合計 1400 円 / 送料 0 円 / 支払い 1400 円

順次は「書いた順に実行される」というあたりまえの形ですが、順番を入れ替えると結果が変わります。 たとえば total = 0 を for の中に移すと、毎回 0 に戻って合計が出ません。プログラムが動く仕組みと3つの形を、3つの言語で書き比べた例は、関連記事「プログラミングとは｜意味・仕組み・言語の種類を3言語の実行で解説」で扱っています。

Python のシーケンス型とは（list・tuple・str・range）

この節では、Python で「シーケンス」と呼ばれる型の種類と、共通してできる操作が、実行結果で分かります。

Python のシーケンス型は、要素が順番に並び、0 から始まる番号（インデックス）で取り出せる型です。 Python の公式ドキュメントは、基本のシーケンス型を list・tuple・range の3つとし、文字列の str（テキストシーケンス型）と bytes など（バイナリシーケンス型）も別の節で扱っています。

4つの型に、共通の操作を同じように試しました。

import sys
from collections.abc import Sequence, MutableSequence

samples = {
    "list":  [10, 20, 30, 20],
    "tuple": (10, 20, 30, 20),
    "str":   "ABCB",
    "range": range(10, 50, 10),
}
print(f"{'型':6}{'s[0]':>6}{'s[-1]':>7}{'s[1:3]':>20}{'len':>5}{'count':>7}{'index':>7}")
for name, s in samples.items():
    x = s[1]
    print(f"{name:6}{s[0]!r:>6}{s[-1]!r:>7}{s[1:3]!r:>20}{len(s):>5}{s.count(x):>7}{s.index(x):>7}")

for name, s in samples.items():
    print(f"{name:6} Sequence={isinstance(s, Sequence)!s:5}  MutableSequence={isinstance(s, MutableSequence)}")
for s in ({1, 2, 3}, {"a": 1}):
    print(f"{type(s).__name__:6} Sequence={isinstance(s, Sequence)}")

型       s[0]  s[-1]              s[1:3]  len  count  index
list      10     20            [20, 30]    4      2      1
tuple     10     20            (20, 30)    4      2      1
str      'A'    'B'                'BC'    4      2      1
range     10     40   range(20, 40, 10)    4      1      1

list   Sequence=True   MutableSequence=True
tuple  Sequence=True   MutableSequence=False
str    Sequence=True   MutableSequence=False
range  Sequence=True   MutableSequence=False
set    Sequence=False
dict   Sequence=False

4つの型すべてで、番号での取り出し・負の番号・スライス・len・count・index が同じ書き方で使えました。 書き換えられる（MutableSequence）のは list だけです。set と dict は番号で取り出せないので、シーケンス型ではありません。

型ごとの違いが出る操作も試しました。

# 連結と繰り返し
[1, 2, 3] (1, 2, 1, 2) ababab
range + range -> TypeError: unsupported operand type(s) for +: 'range' and 'range'

# 書き換え
list -> [99, 2, 3]
tuple -> TypeError: 'tuple' object does not support item assignment
str -> TypeError: 'str' object does not support item assignment
set[0] -> TypeError: 'set' object is not subscriptable

# 範囲外
list[3] -> IndexError: list index out of range
list[1:10] -> [20, 30]
range(10**12) のメモリ: 48 バイト
list(range(10**6)) のメモリ: 8000056 バイト

range は「開始・終了・刻み」だけを覚えているので、1兆個の範囲でも 48 バイトでした。 公式ドキュメントも、range は決まった形の並びしか表せないため、連結と繰り返しには対応しない、と説明しています。範囲外の番号は IndexError になりますが、スライスは範囲外まで指定してもエラーにならず、ある分だけを返しました。

シーケンス図とは（やり取りの順番を描く図）

この節では、設計で使うシーケンス図がどんな図で、どう読むかの入口が分かります。

シーケンス図は、登場する人やシステムのあいだで、メッセージがどの順番でやり取りされるかを、上から下への時間の流れで描く UML の図です。 縦の点線（ライフライン）が登場人物、横の矢印がメッセージ、下に行くほど後の出来事です。

Web のログインを、Mermaid のシーケンス図で描きました。

%%{init: {'sequence': {'actorMargin': 20, 'width': 100}}}%%
sequenceDiagram
    actor U as 利用者
    participant W as Webアプリ
    participant D as DB
    U->>W: IDとパスワード
    W->>D: 利用者を検索
    D-->>W: 結果
    alt 一致
        W-->>U: ログイン成功
    else 不一致
        W-->>U: エラー表示
    end

シーケンス図は「何がどの順で起きるか」、クラス図は「どんな部品があるか」を描く、という役割の違いがあります。 記号の一覧と、alt・loop・par などの枠の使い方、設計書での描き方の型は、関連記事「シーケンス図の書き方｜記号・alt/loop等と実務3パターン」で扱っています。

シーケンス制御とは（PLC とラダー図の考え方）

この節では、電気・機械の分野で使う「シーケンス制御」が何で、ラダー図がどんな考え方で動くかが分かります。

シーケンス制御は、あらかじめ決めた順序や条件に従って、機械の動作を1段階ずつ進めていく制御です。 旧 JIS C 0401 では「あらかじめ定められた順序または手続きに従って制御の各段階を逐次進めていく制御」と定義されています。全自動洗濯機の「給水→洗い→すすぎ→脱水」、信号機、エレベーター、自動ドアが身近な例です。

いまのシーケンス制御は、PLC（プログラマブルロジックコントローラ。日本ではシーケンサとも呼ぶ）という専用のコンピューターで動かすのが一般的です。 PLC は「入力（ボタンやセンサー）を読む → 決めた論理を計算する → 出力（モーターやランプ）を書く」を短い周期で繰り返します。この1周を「スキャン」と呼びます。

PLC のプログラムは、電気の配線図に似た「ラダー図（はしご図）」で書くことが多く、左右の縦線のあいだに、接点（条件）とコイル（出力）を横に並べます。いちばん基本の「自己保持回路」（起動ボタンを離しても回り続け、停止ボタンで止まる）を、文字で描くと次の形です。

 |   起動        停止                 |
 +---| |----+---|/|-------( モーター )-+
 |          |                         |
 |  モーター |                         |
 +---| |----+                         |
 |                                    |
  | | = a接点（押す・ONで通る）  |/| = b接点（押す・ONで切れる）

同じ論理を、スキャンごとの動きとして Python で再現しました（PLC の考え方を見るための模擬です）。

# シーケンス制御の考え方：起動ボタンで回り続け、停止ボタンで止まる（自己保持）
inputs = [  # (起動ボタン, 停止ボタン) をスキャンごとに並べたもの
    (0, 0), (1, 0), (0, 0), (0, 0), (0, 1), (0, 0), (1, 1),
]
motor = 0
print("スキャン 起動 停止 → モーター")
for scan, (start, stop) in enumerate(inputs, 1):
    # ラダー図の1行：( 起動 OR モーター自身 ) AND NOT 停止 → モーター
    motor = int((start or motor) and not stop)
    print(f"{scan:>6} {start:>4} {stop:>4}   →  {'運転' if motor else '停止'}")

スキャン 起動 停止 → モーター
     1    0    0   →  停止
     2    1    0   →  運転
     3    0    0   →  運転
     4    0    0   →  運転
     5    0    1   →  停止
     6    0    0   →  停止
     7    1    1   →  停止

起動ボタンを離した3・4回目のスキャンでも、モーター自身の接点が条件を満たし続けるので運転が続きました。 7回目のように起動と停止を同時に押したときは、停止が勝つように組んであります。止める操作を優先するのが、安全のための基本の組み方です。ラダー図の記号や書き方の決まりは、PLC の言語の国際規格 IEC 61131-3 で定められていて、細かな書き方は PLC のメーカーごとのマニュアルで確かめます。

TCP のシーケンス番号とは

この節では、通信の「シーケンス番号」が何のための番号かが、実際のパケットで分かります。

TCP のシーケンス番号は、送るデータの1バイトごとに付く通し番号です。 受け取った側は、この番号で順番を並べ直し、抜けたところを見つけて再送を頼みます。RFC 9293 は、送ったデータのすべてのバイトにシーケンス番号が付く、と定めています。

手元の HTTP サーバーに curl で1回アクセスし、tcpdump で最初の6つのパケットを見ました（-S で番号をそのまま表示）。

$ tcpdump -i lo -n -S -c 6 'tcp port 38600'
IP 127.0.0.1.56972 > 127.0.0.1.38600: Flags [S], seq 398418432, ... length 0
IP 127.0.0.1.38600 > 127.0.0.1.56972: Flags [S.], seq 1939078404, ack 398418433, ... length 0
IP 127.0.0.1.56972 > 127.0.0.1.38600: Flags [.], ack 1939078405, ... length 0
IP 127.0.0.1.56972 > 127.0.0.1.38600: Flags [P.], seq 398418433:398418511, ack 1939078405, ... length 78
IP 127.0.0.1.38600 > 127.0.0.1.56972: Flags [.], ack 398418511, ... length 0
IP 127.0.0.1.38600 > 127.0.0.1.56972: Flags [P.], seq 1939078405:1939078561, ack 398418511, ... length 156

最初の番号（398418432）は1から始まらない数で、78バイトのリクエストを送ると番号が 398418433 から 398418511 へ78進み、相手は ack 398418511（次はここから）と返しています。 データベースのシーケンスと同じく「順番を表す番号」ですが、使い道は通信の順番の管理です。

シーケンスで起きるエラーと直し方

この節では、データベースの連番と Python のシーケンス型でよく出るエラーを、原文から引けます。

• 1主キーの連番は欠番が出る前提で使うロールバック・エラー・ON CONFLICT で実際に飛んだ
• 2番号の大小で登録順を決めないCACHE 10 では 1, 11, 2, 12 の順に配られた。順番は日時の列で持つ
• 3id を手で入れたら setval で合わせる移行・初期データの投入のあとに、表の最大値とシーケンスを比べる
• 4id の列は bigint にするinteger の上限は約21億。CYCLE は主キーに付けない
• 5欠番を許さない番号は採番テーブルで作るロールバックで戻るが、同時に取ると待ちが出る
• 6setval は1回だけ、値を確かめて実行するロールバックで取り消せず、ほかのセッションにすぐ効く

よくある質問

Q. シーケンスとはわかりやすく言うと何ですか？ A. 「順番に並んだもの」「決まった順に進むこと」です。IT では、データベースの連番・シーケンス図・プログラムの順次処理・Python のシーケンス型・機械のシーケンス制御など、何の順番を扱うかで指すものが変わります。

Q. IT でいうシーケンスの意味は？ A. 会話で単に「シーケンス」と言うときは、データベースで重複しない連番を配るオブジェクトを指すことがいちばん多い言葉です。冒頭の見分け表で、分野ごとの意味をまとめています。

Q. データベースのシーケンスとは？ A. 呼ぶたびに次の番号を返す、番号札の発券機のようなオブジェクトです。PostgreSQL では CREATE SEQUENCE で作り、nextval で番号を取ります。表の id には IDENTITY 列や serial として使います。

Q. シーケンスの番号が飛ぶのはなぜですか？ A. ロールバックやエラーで使われなかった番号も、シーケンスは戻さないからです。同時に配っても待たないための仕様で、PostgreSQL・MySQL とも手元でロールバックした番号が欠番になりました。

Q. シーケンスのキャッシュ（CACHE）とは？ A. セッションが番号をまとめて先に確保しておく個数です。CACHE 10 では、2つのセッションに 1, 11, 2, 12 の順で番号が配られ、閉じたセッションの残りの番号は捨てられました。

Q. シーケンスと AUTO_INCREMENT の違いは？ A. シーケンスは表とは別のオブジェクトで、どの表からも使えます。AUTO_INCREMENT は MySQL の列の性質で、その表の中だけで番号を進めます。MySQL 8.0 では、手で大きい id を入れると次の番号もそこから進みました。

Q. serial と IDENTITY の違いは？ A. どちらも裏でシーケンスを作ります。IDENTITY は SQL 標準の書き方で、GENERATED ALWAYS にすると番号の手入力をエラーで防げます。serial は列の既定値に nextval を書く短縮形です。

Q. シーケンスを1から振り直すには？ A. 全件を消してよいなら TRUNCATE 表 RESTART IDENTITY、シーケンスだけ戻すなら ALTER SEQUENCE 名前 RESTART WITH 1 です。データが残っている表で1に戻すと、既存の id とぶつかります。

Q. シーケンス図とは？ A. 登場人物（利用者・システム・DB）のあいだのやり取りを、時間の順に上から下へ描く UML の図です。実線の矢印が依頼、点線の矢印が返事を表します。

Q. 順次・分岐・反復とは？ A. プログラムの3つの基本の形です。順次は上から順に実行、分岐は条件で道を分ける、反復は同じ処理を繰り返すことで、どんなプログラムもこの組み合わせで書けます。

Q. Python のシーケンス型とは？ A. 番号で要素を取り出せる、順番のある型です。list・tuple・str・range があり、スライス・len・in などを同じ書き方で使えます。書き換えられるのは list だけです。

Q. シーケンス制御とは？ A. 決めた順序や条件で機械の動作を1段階ずつ進める制御で、洗濯機・信号機・エレベーターが例です。PLC（シーケンサ）が、入力を読んで論理を計算し出力を書く処理を繰り返して動かします。

Q. シーケンシャルとはどういう意味ですか？ A. 「順番どおりの・順次の」という意味の形容詞です。シーケンシャルアクセスはデータを先頭から順に読み書きすること、シーケンシャル処理は1つずつ順に処理することを指します。

Q. シーケンス番号とは？ A. 通信では、TCP が送るデータの1バイトごとに付ける通し番号です。受け手はこの番号で順番を並べ直し、抜けを見つけます。手元の通信では、78バイト送ると番号が78進みました。

まとめ

• シーケンスは「順番に並んだもの・順に進むこと」。DB の連番・シーケンス図・順次・Python のシーケンス型・シーケンス制御・TCP の番号で、指すものが違う。
• DB のシーケンスは重複しない番号を配る発券機。PostgreSQL では CREATE SEQUENCE と nextval、表には IDENTITY か serial で使う。
• ロールバック・エラー・ON CONFLICT で番号は戻らず、欠番になった。MySQL の AUTO_INCREMENT も同じで、SQLite の AUTOINCREMENT は戻った。
• CACHE 10 では番号が 1, 11, 2, 12 の順に配られ、セッションを閉じると残りが捨てられた。
• id を手で入れるとシーケンスが遅れて duplicate key になる。setval(…, max(id)) で合わせ、空の表は COALESCE と false を使う。
• 欠番を許さない番号は採番テーブルで作れるが、同時に取ると前の人の COMMIT まで待つ。
• プログラムは順次・分岐・反復の組み合わせ。Python の list・tuple・str・range は共通の操作が使え、書き換えられるのは list だけ。
• シーケンス制御は決めた順で機械を動かす制御で、PLC がラダー図のプログラムをスキャンで繰り返して動かす。

参考・出典

確認日はいずれも 2026年10月23日です。

• コトバンク「シーケンス」（デジタル大辞泉）：https://kotobank.jp/word/%E3%82%B7%E3%83%BC%E3%82%B1%E3%83%B3%E3%82%B9-3904
• ITトレンド「シーケンス とは」：https://it-trend.jp/words/sequence
• @DIME「電気や音楽などでよく使われる言葉「シーケンス」とはどういう意味？」：https://dime.jp/genre/1998458/
• PostgreSQL 16 Documentation「CREATE SEQUENCE」：https://www.postgresql.org/docs/16/sql-createsequence.html
• PostgreSQL 16 Documentation「Sequence Manipulation Functions」：https://www.postgresql.org/docs/16/functions-sequence.html
• PostgreSQL 16 Documentation「CREATE TABLE」：https://www.postgresql.org/docs/16/sql-createtable.html
• MySQL 8.0 Reference Manual「AUTO_INCREMENT Handling in InnoDB」：https://dev.mysql.com/doc/refman/8.0/en/innodb-auto-increment-handling.html
• SQLite「SQLite Autoincrement」：https://www.sqlite.org/autoinc.html
• Oracle Database SQL Language Reference「CREATE SEQUENCE」：https://docs.oracle.com/en/database/oracle/oracle-database/23/sqlrf/CREATE-SEQUENCE.html
• Microsoft Learn「CREATE SEQUENCE (Transact-SQL)」：https://learn.microsoft.com/ja-jp/sql/t-sql/statements/create-sequence-transact-sql
• Microsoft Learn「シーケンス番号」：https://learn.microsoft.com/ja-jp/sql/relational-databases/sequence-numbers/sequence-numbers
• Python ドキュメント「組み込み型（シーケンス型）」：https://docs.python.org/ja/3/library/stdtypes.html
• ウィキペディア「シーケンス制御」：https://ja.wikipedia.org/wiki/シーケンス制御
• IETF「RFC 9293 Transmission Control Protocol (TCP)」：https://www.rfc-editor.org/rfc/rfc9293

株式会社RJC ― SI事業・SES事業・AI駆動開発。RJCは一緒に成長を楽しめる会社です。