Rustでデータベースを設計しよう4

カラム名の衝突や順番依存の設計リスクを解消する
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)]] }

なるほど、ある程度期待通りになっています。

Rustでデータベースを設計しよう3(update, delete)

### 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まではできた。
ここから改善していく。

Rustでデータベースを設計しよう2(insert, create table)

### データ挿入時のエラー処理
impl Tableでinsert_rowとして、カラムにマッチするデータのみ挿入可能とする。

impl Table {
    fn insert_row(&mut self, row: Vec<Value>) -> Result<(), String> {
        if row.len() != self.columns.columns.len() {
            return Err(format!(
                "Row length({}) does not match column count({}",
                row.len(),
                self.columns.columns.len()
            ));
        }

        for (i, (value, column)) in row.iter().zip(&self.columns.columns).enumerate() {
            let expected = column.constraint.to_lowercase();
            let actual = match value {
                Value::Integer(_) => "integer",
                Value::Float(_) => "float",
                Value::Text(_) => "text",
                Value::Boolean(_) => "boolean",
                Value::Date(_) => "date",
                Value::DateTime(_) => "datetime",
                Value::Time(_) => "time",
                Value::Null => "null",
                Value::Binary(_) => "binary",
                Value::UUID(_) => "uuid",
                Value::Json(_) => "json",
                Value::Decimal(_) => "decimal",
            };

            if expected != actual {
                return Err(format!(
                    "Type mismatch at column {} ({}): expected {}, got {}",
                    i, column.name, expected, actual
                ));
            }
        }

        self.rows.push(row);
        Ok(())
    }
}


fn main() {
    let columns = Columns {
        columns: vec![
            Column {
                name: "id".to_string(),
                constraint: "integer".to_string(),
            },
            Column {
                name: "name".to_string(),
                constraint: "text".to_string(),
            },
            Column {
                name: "age".to_string(),
                constraint: "integer".to_string(),
            },
        ]
    };

    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),
    ]);
    println!("{:?}", table);
}

Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.50s
Running `target/debug/rds`
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)]] }

### テーブル作成時のカラムの指定
カラムタイプもenumで指定し、その中のtypeしか設定できないようにする。

#[derive(Debug, Clone, PartialEq)]
enum ColumnType {
    Integer,
    Float,
    Text,
    Boolean,
    Date,
    DateTime,
    Time,
    Null,
    Binary,
    UUID,
    Json,
    Decimal,
}

すると、impl Tableのinsert_rowも以下のようになる。

        for (i, (value, column)) in row.iter().zip(self.columns.columns.iter()).enumerate() {
            if !type_matches(value, &column.constraint) {
                return Err(format!(
                    "Type mismatch at column {} ({}): expected {:?}, got {:?}",
                    i, column.name, column.constraint, value
                ));
            }
        }

//

fn type_matches(value: &Value, column_type: &ColumnType) -> bool {
    match(value, column_type) {
        (Value::Integer(_), ColumnType::Integer) => true,
        (Value::Float(_), ColumnType::Float) => true,
        (Value::Text(_), ColumnType::Text) => true,
        (Value::Boolean(_), ColumnType::Boolean) => true,
        (Value::Date(_), ColumnType::Date) => true,
        (Value::DateTime(_), ColumnType::DateTime) => true,
        (Value::Time(_), ColumnType::Time) => true,
        (Value::Null, ColumnType::Null) => true,
        (Value::Binary(_), ColumnType::Binary) => true,
        (Value::UUID(_), ColumnType::UUID) => true,
        (Value::Json(_), ColumnType::Json) => true,
        (Value::Decimal(_), ColumnType::Decimal) => true,
        _ => false,
    }
}

実際の使用例

fn main() {
    let columns = Columns {
        columns: vec![
            Column {
                name: "id".to_string(),
                constraint: ColumnType::Integer,
            },
            Column {
                name: "name".to_string(),
                constraint: ColumnType::Text,
            },
            Column {
                name: "age".to_string(),
                constraint: ColumnType::Integer,
            },
        ]
    };

    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);
}

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)], [Integer(2), Text(“Bob”), Integer(25)]] }

### 検索機能
colum名と値を指定して、そのレコードを抽出したい

    fn find_rows_by_column_value(&self, column_name: &str, target: &Value) -> Vec<&Vec<Value>> {
        let index = self.columns.columns.iter().position(|col| col.name == column_name);

        if let Some(idx) = index {
            self.rows
                .iter()
                .filter(|row| row.get(idx) == Some(target))
                .collect()
        } else {
            vec![]
        }
    }

//

    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(“Bob”), Integer(25)]

Rustでデータベースを設計しよう1

### Column
カラムは、カラム名と制約が1対1になるので、hashmapを使用する

fn main() {
    let mut columns = HashMap::new();
    columns.insert("id", "integer");
    columns.insert("name", "text");
    columns.insert("age", "integer");

    println!("{:?}", columns);
}

{“name”: “text”, “age”: “integer”, “id”: “integer”}

構造体で書くと以下のようになるが、かなり冗長だ。

#[derive(Debug)]
struct Column {
    name: String,
    constraint: String,
}

#[derive(Debug)]
struct Columns {
    columns: Vec<Column>,
}

fn main() {
    let columns = Columns {
        columns: vec![
            Column {
                name: "id".to_string(),
                constraint: "integer".to_string(),
            },
            Column {
                name: "name".to_string(),
                constraint: "text".to_string(),
            },
            Column {
                name: "age".to_string(),
                constraint: "integer".to_string(),
            },
        ]
    };

    println!("{:?}", columns);
}

### Table
テーブルに対して、上記のカラムがある

#[derive(Debug)]
struct Column {
    name: String,
    constraint: String,
}

#[derive(Debug)]
struct Columns {
    columns: Vec<Column>,
}

#[derive(Debug)]
struct Table {
    name: String,
    columns: Columns,
}


fn main() {
    let columns = Columns {
        columns: vec![
            Column {
                name: "id".to_string(),
                constraint: "integer".to_string(),
            },
            Column {
                name: "name".to_string(),
                constraint: "text".to_string(),
            },
            Column {
                name: "age".to_string(),
                constraint: "integer".to_string(),
            },
        ]
    };

    let table = Table {
        name: "users".to_string(),
        columns: columns,
    };
    println!("{:?}", table);
}

Table { name: “users”, columns: Columns { columns: [Column { name: “id”, constraint: “integer” }, Column { name: “name”, constraint: “text” }, Column { name: “age”, constraint: “integer” }] } }

### 実データを挿入する

#[derive(Debug)]
struct Column {
    name: String,
    constraint: String,
}

#[derive(Debug)]
struct Columns {
    columns: Vec<Column>,
}

#[derive(Debug)]
struct Table {
    name: String,
    columns: Columns,
    rows: Vec<Vec<String>>,
}


fn main() {
    let columns = Columns {
        columns: vec![
            Column {
                name: "id".to_string(),
                constraint: "integer".to_string(),
            },
            Column {
                name: "name".to_string(),
                constraint: "text".to_string(),
            },
            Column {
                name: "age".to_string(),
                constraint: "integer".to_string(),
            },
        ]
    };

    let rows = vec![
        vec!["1".to_string(), "Alice".to_string(), "30".to_string()],
        vec!["2".to_string(), "Bob".to_string(), "25".to_string()],
    ];

    let table = Table {
        name: "users".to_string(),
        columns: columns,
        rows: rows,
    };
    println!("{:?}", table);
}

### データ型をenumで定義する

#[derive(Debug, Clone)]
enum Value {
    Integer(i32),
    Float(f64),
    Text(String),
    Boolean(bool),
    Date(NaiveDate),
    DateTime(NaiveDateTime),
    Time(NaiveTime),
    Null,
    Binary(Vec<u8>),
    UUID(Uuid),
    Json(JsonValue),
    Decimal(Decimal),
}

データ挿入の書き方は以下のようになる。

    let rows = vec![
        vec![Value::Integer(1), Value::Text("Alice".to_string()), Value::Integer(30)],
        vec![Value::Integer(2), Value::Text("Bob".to_string()), Value::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)], [Integer(2), Text(“Bob”), Integer(25)]] }

データ挿入のところをimplで書きたい。

RDS

テーブルとカラムを表現するには、hashmap< Vector > となるだろうか?

class Table:
    def __init__(self, name, columns):
        self.name = name
        self.columns = columns
        self.rows = []

    def insert(self, values):
        if len(values) != len(self.columns):
            raise ValueError("列の数と値の数が一致しません。")
        row = dict(zip(self.columns, values))
        self.rows.append(row)

    def select_all(self):
        return self.rows

    def __str__(self):
        lines = [" | ".join(self.columns)]
        lines.append("-" * len(lines[0]))
        for row in self.rows:
            lines.append(" | ".join(str(row[col]) for col in self.columns))
        return "\n".join(lines)

class Database:
    def __init__(self):
        self.tables = {}

    def create_table(self, name, columns):
        if name in self.tables:
            raise ValueError(f"テーブル '{name}' は既に存在します。")
        self.tables[name] = Table(name, columns)

    def insert_into(self, table_name, values):
        self.tables[table_name].insert(values)

    def select_all(self, table_name):
        return self.tables[table_name].select_all()

    def show_table(self, table_name):
        print(self.tables[table_name])

if __name__ == "__main__":
    db = Database()
    db.create_table("users", ["id", "name", "email"])
    db.insert_into("users", [1, "Alice", "alice@example.com"])
    db.insert_into("users", [2, "Bob", "bob@example.com"])

    print("📄 users テーブル内容:")
    db.show_table("users")

    print("\n📋 SELECT * FROM users:")
    for row in db.select_all("users"):
        print(row)

$ python3 app.py
📄 users テーブル内容:
id | name | email
—————–
1 | Alice | alice@example.com
2 | Bob | bob@example.com

📋 SELECT * FROM users:
{‘id’: 1, ‘name’: ‘Alice’, ’email’: ‘alice@example.com’}
{‘id’: 2, ‘name’: ‘Bob’, ’email’: ‘bob@example.com’}

【Python】NoSQL【Rust】

import json
import os
from typing import List, Dict, Any

class SimpleNoSQL:
    def __init__(self, db_path: str= "db.json"):
        self.db_path = db_path
        if os.path.exists(self.db_path):
            with open(self.db_path, "r") as f:
                self.data = json.load(f)
        else:
            self.data = []

    def save(self):
        with open(self.db_path, "w") as f:
            json.dump(self.data, f, indent=2)

    def insert(self, document: Dict[str, Any]):
        self.data.append(document)
        self.save()

    def find(self, query: Dict[str, Any]) -> List[Dict[str, Any]]:
        def match(doc):
            return all(doc.get(k) == v for k, v in query.items())
        return [doc for doc in self.data if match(doc)]

    def update(self, query: Dict [str, Any], update_fields: Dict[str, Any]):
        for doc in self.data:
            if all(doc.get(k) == v for k, v in query.items()):
                 doc.update(update_fields)
        self.save()

    def delete(self, query: Dict[str, Any]):
        self.data = [doc for doc in self.data if not all(doc.get(k) == v for k, v in query.items())]
        self.save

db = SimpleNoSQL()

db.insert({
    "session_id": "abc123",
    "code": "fn main() { println!(\"Hello\"); }",
    "output": "Hello",
    "status": "success"
})

results = db.find({"session_id": "abc123"})
print("検索結果:", results)

db.update({"session_id": "abc123"}, {"status": "reviewed"})

[
{
“session_id”: “abc123”,
“code”: “fn main() { println!(\”Hello\”); }”,
“output”: “Hello”,
“status”: “reviewed”
}
]

これをRustでやりたい

### Rustでのjsonの保存

use std::collections::HashMap;
use std::fs::File;
use std::io::Write;
use serde::{Serialize, Deserialize};

fn json_w() -> std::io::Result<()> {
    let mut map = HashMap::new();
    map.insert("name", "Alice");
    map.insert("city", "Tokyo");
    map.insert("language", "Rust");

    let json = serde_json::to_string_pretty(&map).expect("Failed to serialize");
    let mut file = File::create("output.json")?;
    file.write_all(json.as_bytes())?;
    
    println!("{:?}", json);
    Ok(())
}

fn main() {
    let _ = json_w();
}

### jsonの読み取り

fn json_r() {
    let data = fs::read_to_string("output.json").expect("Failed to read file");
    let map: HashMap<String, String> = serde_json::from_str(&data).expect("Failed to deserialize");

    println!("{:#?}", map);    
}

{
“name”: “Alice”,
“language”: “Rust”,
“city”: “Tokyo”,
}

### 改修
レコードごとに保存する必要があるので HashMap から Vec> に変更

fn json_w() -> std::io::Result<()> {
    let mut data: Vec<HashMap<String, String>> = match File::open("output.json") {
        Ok(mut file) => {
            let mut contents = String::new();
            file.read_to_string(&mut contents)?;
            serde_json::from_str(&contents).unwrap_or_else(|_| Vec::new())
        },
        Err(_) => Vec::new(),
    };

    let mut map = HashMap::new();
    // map.insert("name".to_string(), "Alice".to_string());
    // map.insert("city".to_string(), "Tokyo".to_string());
    // map.insert("language".to_string(), "Rust".to_string());

    map.insert("name".to_string(), "Bob".to_string());
    map.insert("city".to_string(), "Osaka".to_string());
    map.insert("language".to_string(), "Go".to_string());

    data.push(map);

    let json = serde_json::to_string_pretty(&data).expect("Failed to serialize");
    let mut file = File::create("output.json")?;
    file.write_all(json.as_bytes())?;

    println!("{:?}", json);
    Ok(())
}

fn json_r() {
    let data = fs::read_to_string("output.json").expect("Failed to read file");
    let v: Vec<HashMap<String, String>> = serde_json::from_str(&data).expect("Failed to deserialize");

    println!("{:#?}", v);    
}

fn main() {
    // 
    // let _ = json_w();
    let _ = json_r();
}

[
{
“language”: “Rust”,
“name”: “Alice”,
“city”: “Tokyo”,
},
{
“city”: “Osaka”,
“language”: “Go”,
“name”: “Bob”,
},
]

### implで表現する
関数をinsert, selectとする

use std::collections::HashMap;
use std::fs;
use std::fs::{File};
use std::io::{Read, Write};
use serde::{Serialize, Deserialize};

pub static FILE_NAME : &'static str = "output.json";

struct NoSQL {
    data: Vec<HashMap<String, String>>,
}

impl NoSQL {
    fn insert(&mut self, map: HashMap<String, String>) -> std::io::Result<()> {
        self.data = match File::open(FILE_NAME) {
            Ok(mut file) => {
                let mut contents = String::new();
                file.read_to_string(&mut contents)?;
                serde_json::from_str(&contents).unwrap_or_else(|_| Vec::new())
            },
            Err(_) => Vec::new(),
        };        
        self.data.push(map);

        let json = serde_json::to_string_pretty(&self.data).expect("Failed to serialize");
        let mut file = File::create(FILE_NAME)?;
        file.write_all(json.as_bytes())?;

        println!("{:?}", json);
        Ok(())
    }

    fn select(&self) {
        let data = fs::read_to_string(FILE_NAME).expect("Failed to read file");
        let v: Vec<HashMap<String, String>> = serde_json::from_str(&data).expect("Failed to deserialize");
    
        println!("{:#?}", v);    
    }
}

fn main() {
    let mut sql = NoSQL{ data: Vec::new() };

    let mut map = HashMap::new();
    map.insert("name".to_string(), "Bob".to_string());
    map.insert("city".to_string(), "Osaka".to_string());
    map.insert("language".to_string(), "Go".to_string());

    sql.insert(map);
    sql.select();
}

こうすると、nosqlは単純にVec>,と言える。
インメモリデータベースの場合は、メモリに保存するので、jsonではなく、単純にデータとして持っておくだけになる。その場合、サイズが動的なので、スタックではなく、ヒープに保存される。

Rustのplaygroundを作る

html

<!DOCTYPE html>
<html lang="ja">
<head>
  <meta charset="UTF-8">
  <title>Rust Execute</title>
  <style>
    #editor { width: 800px; height: 300px; }
    #output { white-space: pre-wrap; border: 1px solid #ccc; padding: 10px; margin-top: 10px; }
  </style>
</head>
<body>
  <h2>Rust Editor</h2>
  <div id="editor"></div>
  <button onclick="runRust()">Run</button>
  <h3>Output</h3>
  <div id="output"></div>
  <script src="https://unpkg.com/monaco-editor@0.45.0/min/vs/loader.js"></script>
  <script>
    let editor;
    require.config({ paths: { vs: 'https://unpkg.com/monaco-editor@0.45.0/min/vs' }});
    require(['vs/editor/editor.main'], function () {
      editor = monaco.editor.create(document.getElementById('editor'), {
        value: `fn main() {\n    println!("Hello from Rust!");\n}`,
        language: 'rust',
        theme: 'vs-dark'
      });
    });

    async function runRust() {
      const code = editor.getValue();
      const res = await fetch('/run-rust', {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({ code })
      });
      const result = await res.text();
      document.getElementById('output').innerText = result;
    }
  </script>
</body>
</html>

node

const express = require('express');
const bodyParser = require('body-parser');
const fs = require('fs');
const { exec } = require('child_process');
const path = require('path');

const app = express();
app.use(bodyParser.json());
app.use(express.static(__dirname)); 

app.post('/run-rust', (req, res) => {
    const code = req.body.code;
    const filename = `temp_${Date.now()}.rs`;
    const filepath = path.join(__dirname, filename);

    fs.writeFileSync(filepath, code);    
    const outputBinary = filepath.replace('.rs', '');

    exec(`rustc ${filepath} -o ${outputBinary}`, (err, _, stderr) => {
        if (err) {
            fs.unlinkSync(filepath);
            return res.send(`コンパイルエラー:\n${stderr}`);
        }

        exec(outputBinary, (runErr, stdout, runStderr) => {
            fs.unlinkSync(filepath);
            fs.unlinkSync(outputBinary);
      
            if (runErr) {
              return res.send(`実行エラー:\n${runStderr}`);
            }
      
            res.send(stdout);
        });
    });
});

const PORT = 3000;
const HOST = '192.168.33.10';
app.listen(PORT, HOST, () => console.log(`http://192.168.33.10:${PORT} で実行中`));

Monaco Editorを試す【Javascript】

ブラウザをエディターとして使用できるようになります。
language: ‘javascript’と書いているところで、好みの言語に変更できる。

<!Doctype html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Monaco Editor Sample</title>
    <style>
    #container {
      width: 800px;
      height: 600px;
      border: 1px solid grey;
    }
  </style>
</head>
<body>
    <h1>Monaco Editor demo</h1>
    <div id="container"></div>
    <script src="https://unpkg.com/monaco-editor@0.45.0/min/vs/loader.js"></script>
    <script>
        require.config({ paths: { 'vs': 'https://unpkg.com/monaco-editor@0.45.0/min/vs' }});
        require(['vs/editor/editor.main'], function(){
            monaco.editor.create(document.getElementById('container'), {
                value: [
                'function hello() {',
                '\tconsole.log("Hello, Monaco!");',
                '}',
                'hello();'
                ].join('\n'),
                language: 'javascript',
                theme: 'vs-dark'
            });
        });
    </script>
</body>
</html>

なるほど!

入力内容をファイルにするには

        let editor;

        require.config({ paths: { 'vs': 'https://unpkg.com/monaco-editor@0.45.0/min/vs' }});
        require(['vs/editor/editor.main'], function(){
            editor = monaco.editor.create(document.getElementById('container'), {
                value: [
                    'fn main() {',
                    '    println!("Hello, Rust!");',
                    '}'
                ].join('\n'),
                language: 'rust',
                theme: 'vs-dark'
            });
        });

        function saveAsFile(filename, content) {
            const blob = new Blob([content], { type: 'text/plain;charset=utf-8' });
            const link = document.createElement("a");
            link.href = URL.createObjectURL(blob);
            link.download = filename;
            document.body.appendChild(link);
            link.click();
            document.body.removeChild(link);
        }

        document.getElementById('saveBtn').addEventListener('click', () => {
        const code = editor.getValue();
        saveAsFile("main.rs", code);
        });

【Python】editor

import curses

def main(stdscr):
    curses.curs_set(1)
    stdscr.clear()
    stdscr.refresh()

    text = []
    row = 0

    while True:
        stdscr.move(row, 0)
        stdscr.clrtoeol()
        stdscr.addstr(row, 0, ''.join(text))
        stdscr.refresh()
        ch = stdscr.getch()

        if ch == 27:  # ESCキーで終了
            break
        elif ch == 10:  # Enter
            text.append('\n')
            row += 1
        elif ch == 127 or ch == curses.KEY_BACKSPACE:
            if text:
                text.pop()
                if text[-1] == '\n':
                    row -= 1
        else:
            text.append(chr(ch))

    with open("output.txt", "w") as f:
        f.write(''.join(text))
    

curses.wrapper(main)

Rustで書くと

use crossterm::{
    cursor,
    event::{read, Event, KeyCode},
    terminal::{enable_raw_mode, disable_raw_mode, ClearType},
    ExecutableCommand,
};
use std::io::{stdout, Write};
use std::fs::File;

fn main() -> std::io::Result<()> {
    let mut stdout = stdout();
    let mut buffer = String::new();

    enable_raw_mode()?;
    stdout.execute(crossterm::terminal::Clear(ClearType::All))?;
    stdout.execute(cursor::MoveTo(0, 0))?;

    loop {
        match read()? {
            Event::Key(event) => match event.code {
                KeyCode::Char(c) => {
                    buffer.push(c);
                    print!("{}", c);
                    stdout.flush()?;
                }
                KeyCode::Enter => {
                    buffer.push('\n');
                    print!("\r\n");
                    stdout.flush()?;
                }
                KeyCode::Backspace => {
                    buffer.pop();
                    stdout.execute(cursor::MoveLeft(1))?;
                    print!(" ");
                    stdout.execute(cursor::MoveLeft(1))?;
                    stdout.flush()?;
                }
                KeyCode::Esc => {
                    break;
                }
                _ => {}
            },
            _ => {}
        }
    }

    disable_raw_mode()?;

    let mut file = File::create("output.txt")?;
    write!(file, "{}", buffer)?;

    Ok(())
}

inputファイルを読み込んで、出力

use crossterm::{
    cursor,
    event::{read, Event, KeyCode},
    terminal::{enable_raw_mode, disable_raw_mode, ClearType},
    ExecutableCommand,
};
use std::io::{stdout, Write};
use std::fs::{File, read_to_string};

fn main() -> std::io::Result<()> {
    let mut stdout = stdout();
    let mut buffer = String::new();

    let initial_text = match read_to_string("input.txt") {
        Ok(content) => content,
        Err(_) => String::new(),
    };
    buffer.push_str(&initial_text);

    enable_raw_mode().expect("Failed to enable raw mode");
    stdout.execute(crossterm::terminal::Clear(ClearType::All))?;
    stdout.execute(cursor::MoveTo(0, 0))?;

    let mut row: u16 = 0;
    let mut col: u16 = 0;
    for ch in buffer.chars() {
        match ch {
            '\n' => {
                print!("\r\n");
                row += 1;
                col = 0;
            }
            _ => {
                print!("{}", ch);
                col += 1;
            }
        }
    }
    stdout.flush()?;

    stdout.execute(cursor::MoveTo(col, row))?;

    loop {
        match read()? {
            Event::Key(event) => match event.code {
                KeyCode::Char(c) => {
                    buffer.push(c);
                    print!("{}", c);
                    stdout.flush()?;
                }
                KeyCode::Enter => {
                    buffer.push('\n');
                    row += 1;
                    print!("\r\n");
                    stdout.flush()?;
                }
                KeyCode::Backspace => {
                    buffer.pop();
                    stdout.execute(cursor::MoveLeft(1))?;
                    print!(" ");
                    stdout.execute(cursor::MoveLeft(1))?;
                    stdout.flush()?;
                }
                KeyCode::Esc => {
                    break;
                }
                _ => {}
            },
            _ => {}
        }
    }

    disable_raw_mode()?;

    let mut file = File::create("output.txt")?;
    write!(file, "{}", buffer)?;

    Ok(())
}

input.txtを行単位で読み込んで出力するなどの工夫が必要

【Rust】RwLockの使い所

複数スレッドで読み取りは同時、書き込みは排他


use std::sync::{Arc, RwLock};
use std::thread;

fn main() {
    let data = Arc::new(RwLock::new(5));

    let readers: Vec<_> = (0..3).map(|i| {
        let data = Arc::clone(&data);
        thread::spawn(move || {
            let read = data.read().unwrap();
            println!("Thread {} read: {}", i, *read);
        })
    }).collect();

    {
        let mut write = data.write().unwrap();
        *write += 1;
        println!("Main thread wrote: {}", *write);
    }

}

書き込みが多い場合はmutex向き