ソフトウェアエンジニアの技術ブログ：Software engineer tech blog

### Chat GTP
– ブラウザやアプリでチャット形式
– モデル: GPT-4（Pro版）または GPT-3.5（無料）
– 補完のタイミング: 会話でまとめて質問・回答
– 用途: 質問・学習・エラー解析・仕様理解など広範囲
– 自然言語で深く対話可能
– 会話履歴を踏まえて提案

### GitHub Copilot
– Visual Studio Code / JetBrains / Neovim などで直接使う
– Codex（GPT-3系列）または Copilot専用モデル
– コードを書く「途中」でリアルタイム補完
– 手を動かしてコードを書くときの補助
– コメントやコードの一部を見て予測
– 開いているファイルや周辺コードだけで判断

Copilotでコードを書きながら、ChatGPTで「このコードの意味は？」「エラーの原因は？」と調べるのが効率的とのこと。

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