随机应变 ABCD: Always Be Coding and … : хороший
### Chat GTP
– ブラウザやアプリでチャット形式
– モデル: GPT-4（Pro版）または GPT-3.5（無料）
– 補完のタイミング: 会話でまとめて質問・回答
– 用途: 質問・学習・エラー解析・仕様理解など広範囲
– 自然言語で深く対話可能
– 会話履歴を踏まえて提案
### GitHub Copilot
– Visual Studio Code / JetBrains / Neovim などで直接使う
– Codex（GPT-3系列）または Copilot専用モデル
– コードを書く「途中」でリアルタイム補完
– 手を動かしてコードを書くときの補助
– コメントやコードの一部を見て予測
– 開いているファイルや周辺コードだけで判断
Copilotでコードを書きながら、ChatGPTで「このコードの意味は？」「エラーの原因は？」と調べるのが効率的とのこと。
[オンプレサーバの構成イメージ]
オンプレサーバ
↓
スイッチ
↓
ルータ or ファイヤウォール
↓
ONU(回線終端装置)
↓
光回線
### スイッチ: 社内機器を相互に接続する
中小企業向け: Cisco(Catalyst 1000 シリーズ), YAMAHA(SWX2200 シリーズ), NETGEAR(GS110TP, GS752TP)
中大企業向け: Cisco(Catalyst 9300, 9500シリーズ), Juniper(EX3400, EX4300), HPE Aruba(Aruba 2930F)
—
LAN内の通信を中継・管理
MACアドレスをもとに、必要なポートにだけデータを転送
**VLAN（仮想LAN）**によるセグメント分けも可能（セキュリティ・パフォーマンス向上）
L3スイッチなら、**セグメント間ルーティング（簡易ルータ機能）**も持つ
### ルータ/ファイヤフォール
中小企業向け: Cisco(Catalyst 1000 シリーズ), YAMAHA(SWX2200 シリーズ), NETGEAR(GS110TP, GS752TP)
中大企業向け: Palo Alto Networks, Fortinet, Cisco
—
ルータ：異なるネットワーク間（例：社内LAN ↔ インターネット）を中継
ファイアウォール：通信のフィルタリング・遮断で、社内ネットワークを保護
ルータの主な機能：
パケットの転送（ルーティング）
NAT変換（社内のプライベートIP ⇄ インターネットのグローバルIP）
DHCPやDNSリレー機能など
🟥 ファイアウォールの主な機能：
ポート制御／IP制限／アクセス制御（ACL）
外部からの不正アクセスをブロック
次世代型ではアンチウイルスやアプリ制御も（UTM機能）
### ONU（光回線終端装置）
NTT東西: PR-500KI、RT-500MI、RV-440NEなど
KDDI（auひかり）: BL1000HW など
ソフトバンク光: HGW（型番非公開が多い）
—-
役割：光ファイバー信号（アナログ）を、デジタル信号に変換してルータへ渡す中継機器
amazonで製品名を検索すると、法人向けスイッチやルータ/ファイヤウォールがどんなものかイメージが掴める。
lib.rs と main.rs の両方があると、Rust は自動的にlib.rs をライブラリとしてビルドする仕組みとなっている。
lib.rs
pub fn greet(name: &str) -> String {
format!("Hello, {}!", name)
}
main.rs
use app::greet;
fn main() {
let name = "Alice";
println!("{}", greet(name));
}
Compiling app v0.1.0 (/home/vagrant/dev/work/rust/app)
Finished `dev` profile [unoptimized + debuginfo] target(s) in 2.45s
Running `target/debug/app`
Hello, Alice!
なるほど、lib.rs はRust関連の書籍を見るとよく出てきますが、ようやく意味がわかりました。
#[cfg(test)]
mod tests {
use super::*;
use std::collections::HashMap;
fn create_test_table() -> Table {
let mut schema = HashMap::new();
let mut order = vec![];
let columns = vec![
("id", ColumnType::Integer, Constraint::PrimaryKey),
("name", ColumnType::Text, Constraint::None),
("age", ColumnType::Integer, Constraint::None),
];
for(i, (name, col_type, constraint)) in columns.into_iter().enumerate(){
schema.insert(
name.to_string(),
ColumnSchema {
order: i,
column_type: col_type,
constraint,
},
);
order.push(name.to_string());
}
Table {
name: "users".to_string(),
columns: Columns { schema, order },
rows: vec![],
}
}
#[test]
fn test_insert_and_find() {
let mut table = create_test_table();
let result = table.insert_row(vec![
Value::Integer(1),
Value::Text("Alice".to_string()),
Value::Integer(30),
]);
assert!(result.is_ok());
let results = table.find_rows_by_column_value("id", &Value::Integer(1));
assert_eq!(results.len(), 1);
assert_eq!(results[0][1], Value::Text("Alice".to_string()));
}
#[test]
fn test_update_by_condition() {
let mut table = create_test_table();
table.insert_row(vec![
Value::Integer(2),
Value::Text("Bob".to_string()),
Value::Integer(25),
]).unwrap();
let condition = Condition::Equals("id".to_string(), Value::Integer(2));
let updated = table.update_by_condition("name", Value::Text("Carol".to_string()), Some(condition)).unwrap();
assert_eq!(updated, 1);
let updated_rows = table.find_rows_by_column_value("id", &Value::Integer(2));
assert_eq!(updated_rows[0][1], Value::Text("Carol".to_string()));
}
#[test]
fn test_delete_by_condition() {
let mut table = create_test_table();
table.insert_row(vec![
Value::Integer(3),
Value::Text("David".to_string()),
Value::Integer(40),
]).unwrap();
let condition = Condition::Equals("id".to_string(), Value::Integer(3));
let deleted = table.delete_by_condition(Some(condition)).unwrap();
assert_eq!(deleted, 1);
let rows = table.find_rows_by_column_value("id", &Value::Integer(3));
assert_eq!(rows.len(), 0);
}
#[test]
fn test_unique_violation() {
let mut table = create_test_table();
table.insert_row(vec![
Value::Integer(4),
Value::Text("Eve".to_string()),
Value::Integer(50),
]).unwrap();
let result = table.insert_row(vec![
Value::Integer(4),
Value::Text("Eve2".to_string()),
Value::Integer(60),
]);
assert!(result.is_err());
assert!(result.unwrap_err().contains("Duplicate primary key"));
}
}
Finished `test` profile [unoptimized + debuginfo] target(s) in 4.35s
Running unittests src/main.rs (target/debug/deps/rds-a17132f561100387)
running 4 tests
test tests::test_insert_and_find … ok
test tests::test_delete_by_condition … ok
test tests::test_unique_violation … ok
test tests::test_update_by_condition … ok
test result: ok. 4 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
プロジェクトを lib.rs + main.rs に分けたい。
use regex::Regex;
fn main() {
let text = "CREATE TABLE users (
id integer,
name text,
age integer,
);";
println!("{}", text);
let table_re = Regex::new(r"(?i)create\s+table\s+([a-zA-Z_][a-zA-Z0-9_]*)\s*\((?s)(.*?)\)").unwrap();
if let Some(caps) = table_re.captures(text) {
let table_name = &caps[1];
let columns_str = &caps[2];
println!("table name: {}", table_name);
let column_re = Regex::new(r"(?i)([a-zA-Z_][a-zA-Z0-9_]*)\s+([a-zA-Z0-9()]+)").unwrap();
for line in columns_str.lines() {
if let Some(col_caps) = column_re.captures(line.trim()) {
let column_name = &col_caps[1];
let column_type = &col_caps[2];
println!(" column name: {}, type: {}", column_name, column_type);
}
}
} else {
println!("CREATE TABLE 文ではありません");
}
}
CREATE TABLE users (
id integer,
name text,
age integer,
);
table name: users
column name: id, type: integer
column name: name, type: text
column name: age, type: integer
これにprimary keyなどのconstrainも追加したい…
fn main() {
let text = "CREATE TABLE users (
id integer primarykey,
name text not null,
age integer
);";
println!("{}", text);
let table_re = Regex::new(r"(?is)create\s+table\s+([a-zA-Z_][a-zA-Z0-9_]*)\s*\((.*?)\)").unwrap();
if let Some(caps) = table_re.captures(text) {
let table_name = &caps[1];
let columns_str = &caps[2];
println!("table name: {}", table_name);
let column_re = Regex::new(r"(?i)^\s*([a-zA-Z_][a-zA-Z0-9_]*)\s+([a-zA-Z0-9()]+)(?:\s+(.*))?[,]?$").unwrap();
for line in columns_str.lines() {
let line = line.trim();
if line.is_empty() {
continue;
}
if let Some(col_caps) = column_re.captures(line) {
let column_name = &col_caps[1];
let column_type = &col_caps[2];
let constraint = col_caps.get(3).map_or("", |m| m.as_str()).trim();
println!(" column name: {}, type: {}, constraint: {}", column_name, column_type, if constraint.is_empty() { "None" } else { constraint });
} else {
println!(" ignored row: {}", line);
}
}
} else {
println!("CREATE TABLE 文ではありません");
}
}
CREATE TABLE users (
id integer primarykey,
name text not null,
age integer
);
table name: users
column name: id, type: integer, constraint: primarykey,
column name: name, type: text, constraint: not null,
column name: age, type: integer, constraint: None
cargo.tomlでbincode = “1.3”を設定する
fn save_to_binary_file(&self, path: &str) -> Result<(), String> {
let encoded = bincode::serialize(self).map_err(|e| e.to_string())?;
let mut file = File::create(path).map_err(|e| e.to_string())?;
file.write_all(&encoded).map_err(|e| e.to_string())?;
Ok(())
}
fn load_from_binary_file(path: &str) -> Result<Table, String> {
let mut file = File::open(path).map_err(|e| e.to_string())?;
let mut buffer = Vec::new();
file.read_to_end(&mut buffer).map_err(|e| e.to_string())?;
let table: Table = bincode::deserialize(&buffer).map_err(|e| e.to_string())?;
Ok(table)
}
fn main()
let mut table = create_sample_table();
table.save_to_binary_file("users.bin").expect("Failed to save binary");
let loaded = Table::load_from_binary_file("users.bin").expect("Failed to load binary");
println!("読み込んだtable: {:?}", loaded);
読み込んだtable: Table { name: “users”, columns: Columns { schema: {“name”: ColumnSchema { order: 1, column_type: Text, constraint: None }, “id”: ColumnSchema { order: 0, column_type: Integer, constraint: PrimaryKey }, “age”: ColumnSchema { order: 2, column_type: Integer, constraint: None }}, order: [“id”, “name”, “age”] }, rows: [[Integer(1), Text(“Alice”), Integer(30)], [Integer(2), Text(“Bob”), Integer(25)]] }
$ cat users.bin
usersidnameageidnameageAliceBob
impl Tableで、jsonの保存、読み取り関数を書く。export_to_json()でjson化を関数にしているので、それを実行して、write_allで書き込む。読み取りの場合は、read_to_string()
fn save_to_file(&self, path: &str) -> Result<(), String> {
let json = self.export_to_json();
let serialized = serde_json::to_string_pretty(&json)
.map_err(|e| e.to_string())?;
let mut file = File::create(path).map_err(|e| e.to_string())?;
file.write_all(serialized.as_bytes()).map_err(|e| e.to_string())?;
Ok(())
}
fn load_from_file(path: &str) -> Result<Table, String> {
let mut file = File::open(path).map_err(|e| e.to_string())?;
let mut contents = String::new();
file.read_to_string(&mut contents).map_err(|e| e.to_string())?;
let json: JsonValue = serde_json::from_str(&contents).map_err(|e| e.to_string())?;
Table::import_from_json(&json)
}
### 保存、読み取りの実行
サンプルテーブルは関数で別に作っておく
fn create_sample_table() -> Table {
let mut schema = HashMap::new();
let mut order = vec![];
let columns = vec![
("id", ColumnType::Integer, Constraint::PrimaryKey),
("name", ColumnType::Text, Constraint::None),
("age", ColumnType::Integer, Constraint::None),
];
for (i, (name, col_type, constraint)) in columns.into_iter().enumerate() {
schema.insert(name.to_string(), ColumnSchema {
order: i,
column_type: col_type,
constraint,
});
order.push(name.to_string());
}
let columns = Columns { schema, order };
let mut table = Table {
name: "users".to_string(),
columns: columns,
rows: vec![],
};
let result = table.insert_row(vec![
Value::Integer(1),
Value::Text("Alice".to_string()),
Value::Integer(30),
]);
let result = table.insert_row(vec![
Value::Integer(2),
Value::Text("Bob".to_string()),
Value::Integer(25),
]);
table
}
let mut table = create_sample_table();
if let Err(e) = table.save_to_file("users.json") {
eprintln!("保存に失敗しました: {}", e);
}
match Table::load_from_file("users.json") {
Ok(loaded_table) => {
println!("読み込み成功: {:?}", loaded_table);
}
Err(e) => {
eprintln!("読み込み失敗: {}", e);
}
}
読み込み成功: Table { name: “users”, columns: Columns { schema: {“id”: ColumnSchema { order: 0, column_type: Integer, constraint: PrimaryKey }, “age”: ColumnSchema { order: 2, column_type: Integer, constraint: None }, “name”: ColumnSchema { order: 1, column_type: Text, constraint: None }}, order: [“id”, “name”, “age”] }, rows: [[Integer(1), Text(“Alice”), Integer(30)], [Integer(2), Text(“Bob”), Integer(25)]] }
### psqlのデータ保存
– 独自のフォーマットでファイルにテーブルデータを格納
– 各テーブルは内部的に「リレーション」として表され、base/ ディレクトリ以下にファイルとして存在
– PostgreSQL はデフォルトで 8KB 単位のページにデータを分割して保存
### mysqlのデータ保存
– 通常は /var/lib/mysql/ ディレクトリに保存されます。各データベースはサブディレクトリとして管理
– デフォルトでは1つの共有表領域ファイル（ibdata1）にすべてのデータを保存
どちらのDBMSも、保存しているファイルは バイナリ形式
#[derive(Debug, Clone)]
enum Condition {
Equals(String, Value),
NotEquals(String, Value),
And(Box<Condition>, Box<Condition>),
Or(Box<Condition>, Box<Condition>),
}
fn row_matches_condition(&self, row: &Vec<Value>, condition: &Condition) -> bool {
match condition {
Condition::Equals(col, val) => {
if let Some(schema) = self.columns.schema.get(col) {
row.get(schema.order) == Some(val)
} else {
false
}
}
Condition::NotEquals(col, val) => {
if let Some(schema) = self.columns.schema.get(col) {
row.get(schema.order) != Some(val)
} else {
false
}
}
Condition::And(lhs, rhs) => {
self.row_matches_condition(row, lhs) && self.row_matches_condition(row, rhs)
}
Condition::Or(lhs, rhs) => {
self.row_matches_condition(row, lhs) || self.row_matches_condition(row, rhs)
}
}
}
fn find_rows_by_condition(&self, condition: &Condition) -> Vec<&Vec<Value>> {
self.rows
.iter()
.filter(|row| self.row_matches_condition(row, condition))
.collect()
}
//
let _ = table.update_value_by_column_condition(
"id",
&Value::Integer(2),
"name",
Value::Text("Carol".to_string()),
);
let condition = Condition::And(
Box::new(Condition::Equals("age".to_string(), Value::Integer(25))),
Box::new(Condition::NotEquals("name".to_string(), Value::Text("Bob".to_string()))),
);
let results = table.find_rows_by_condition(&condition);
for row in results {
println!("Match row: {:?}", row);
}
カラム名の衝突や順番依存の設計リスクを解消する
L columnsにcolumのorderを値として持つようにする
#[derive(Debug)]
struct ColumnSchema {
order: usize,
column_type: ColumnType,
}
#[derive(Debug)]
struct Columns {
schema: HashMap<String, ColumnSchema>,
order: Vec<String>,
}
利用側
fn main() {
let mut schema = HashMap::new();
let mut order = vec![];
let columns = vec![
("id", ColumnType::Integer),
("name", ColumnType::Text),
("age", ColumnType::Integer),
];
for (i, (name, col_type)) in columns.into_iter().enumerate() {
schema.insert(name.to_string(), ColumnSchema {
order: i,
column_type: col_type,
});
order.push(name.to_string());
}
let columns = Columns { schema, order };
let mut table = Table {
name: "users".to_string(),
columns: columns,
rows: vec![],
};
let result = table.insert_row(vec![
Value::Integer(1),
Value::Text("Alice".to_string()),
Value::Integer(30),
]);
let result = table.insert_row(vec![
Value::Integer(2),
Value::Text("Bob".to_string()),
Value::Integer(25),
]);
println!("{:?}", table);
let _ = table.update_value_by_column_condition(
"id",
&Value::Integer(2),
"name",
Value::Text("Carol".to_string()),
);
// let matching_rows = table.find_rows_by_column_value("id", &Value::Integer(2));
// for row in matching_rows {
// println!("Matched row: {:?}", row);
// }
// let matching_rows = table.find_rows_by_column_value("id", &Value::Integer(2));
// for row in matching_rows {
// println!("Matched row: {:?}", row);
// }
let _ = table.delete_rows_by_column_value("id", &Value::Integer(2));
println!("{:?}", table);
}
Table { name: “users”, columns: Columns { schema: {“age”: ColumnSchema { order: 2, column_type: Integer }, “name”: ColumnSchema { order: 1, column_type: Text }, “id”: ColumnSchema { order: 0, column_type: Integer }}, order: [“id”, “name”, “age”] }, rows: [[Integer(1), Text(“Alice”), Integer(30)], [Integer(2), Text(“Bob”), Integer(25)]] }
Table { name: “users”, columns: Columns { schema: {“age”: ColumnSchema { order: 2, column_type: Integer }, “name”: ColumnSchema { order: 1, column_type: Text }, “id”: ColumnSchema { order: 0, column_type: Integer }}, order: [“id”, “name”, “age”] }, rows: [[Integer(1), Text(“Alice”), Integer(30)]] }
なるほど、ある程度期待通りになっています。
### column名とvalueを指定してupdate
fn update_value_by_column_condition(
&mut self,
where_column: &str,
where_value: &Value,
set_column: &str,
new_value: Value,
) -> Result<usize, String> {
let where_index = self.columns.columns.iter().position(|c| c.name == where_column)
.ok_or_else(|| format!("Column '{}' not found", where_column))?;
let set_index = self.columns.columns.iter().position(|c| c.name == set_column)
.ok_or_else(|| format!("Column '{}' not found", set_column))?;
let expected_type = &self.columns.columns[set_index].constraint;
if !type_matches(&new_value, expected_type) {
return Err(format!(
"Type mismatch: column '{}' expects {:?}, got {:?}",
set_column, expected_type, new_value
));
}
let mut updated = 0;
for row in self.rows.iter_mut() {
if let Some(v) = row.get(where_index) {
if v == where_value {
row[set_index] = new_value.clone();
updated += 1;
}
}
}
Ok(updated)
}
let result = table.insert_row(vec![
Value::Integer(2),
Value::Text("Bob".to_string()),
Value::Integer(25),
]);
println!("{:?}", table);
let _ = table.update_value_by_column_condition(
"id",
&Value::Integer(2),
"name",
Value::Text("Carol".to_string()),
);
let matching_rows = table.find_rows_by_column_value("id", &Value::Integer(2));
for row in matching_rows {
println!("Matched row: {:?}", row);
}
Matched row: [Integer(2), Text(“Carol”), Integer(25)]
### delete
fn delete_rows_by_column_value(
&mut self,
column_name: &str,
target: &Value,
) -> Result<usize, String> {
let col_index = self
.columns
.columns
.iter()
.position(|col| col.name == column_name)
.ok_or_else(|| format!("Column '{}' not found", column_name))?;
let original_len = self.rows.len();
self.rows.retain(|row| row.get(col_index) != Some(target));
Ok(original_len - self.rows.len())
}
let matching_rows = table.find_rows_by_column_value("id", &Value::Integer(2));
for row in matching_rows {
println!("Matched row: {:?}", row);
}
let _ = table.delete_rows_by_column_value("id", &Value::Integer(2));
println!("{:?}", table);
Matched row: [Integer(2), Text(“Carol”), Integer(25)]
Table { name: “users”, columns: Columns { columns: [Column { name: “id”, constraint: Integer }, Column { name: “name”, constraint: Text }, Column { name: “age”, constraint: Integer }] }, rows: [[Integer(1), Text(“Alice”), Integer(30)]] }
これで、一通りcreate, insert, select, update, deleteまではできた。
ここから改善していく。