sql_insight 0.1.0.alpha.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 0042e85cbacf9d9be5912be42e3a8c1720d4cd867e671749c701878175c8b4c7
+  data.tar.gz: 5f8b169edd3e3318fad8165df2df143bbb6b0a739d01844cd2e17a48997705fc
+SHA512:
+  metadata.gz: e97d77d0e92929c188ce5d9f008048d5222031c9eb35eb3e577b233a9453759baf78bb503f472c272100f3f1257c6852188aff40082adf7344f0374c00b8388e
+  data.tar.gz: 5c3b3ef60a83b22b5c2cf3d49e55b0b4afb83ef36670c4fb5cdcfbb69e03fc1a4af54b36bebdf6a0db49ba87227535e61dbce7c1203490b203b713b56655a5a6

data/Cargo.lock

@@ -0,0 +1,429 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "aho-corasick"
+version = "1.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b2969dcb958b36655471fc61f7e416fa76033bdd4bfed0678d8fee1e2d07a1f0"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "bindgen"
+version = "0.69.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a00dc851838a2120612785d195287475a3ac45514741da670b735818822129a0"
+dependencies = [
+ "bitflags",
+ "cexpr",
+ "clang-sys",
+ "itertools",
+ "lazy_static",
+ "lazycell",
+ "proc-macro2",
+ "quote",
+ "regex",
+ "rustc-hash",
+ "shlex",
+ "syn",
+]
+
+[[package]]
+name = "bitflags"
+version = "2.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ed570934406eb16438a4e976b1b4500774099c13b8cb96eec99f620f05090ddf"
+
+[[package]]
+name = "cexpr"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6fac387a98bb7c37292057cffc56d62ecb629900026402633ae9160df93a8766"
+dependencies = [
+ "nom",
+]
+
+[[package]]
+name = "cfg-if"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
+
+[[package]]
+name = "clang-sys"
+version = "1.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "67523a3b4be3ce1989d607a828d036249522dd9c1c8de7f4dd2dae43a37369d1"
+dependencies = [
+ "glob",
+ "libc",
+ "libloading",
+]
+
+[[package]]
+name = "either"
+version = "1.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "11157ac094ffbdde99aa67b23417ebdd801842852b500e395a45a9c0aac03e4a"
+
+[[package]]
+name = "glob"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d2fabcfbdc87f4758337ca535fb41a6d701b65693ce38287d856d1674551ec9b"
+
+[[package]]
+name = "itertools"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ba291022dbbd398a455acf126c1e341954079855bc60dfdda641363bd6922569"
+dependencies = [
+ "either",
+]
+
+[[package]]
+name = "lazy_static"
+version = "1.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
+
+[[package]]
+name = "lazycell"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "830d08ce1d1d941e6b30645f1a0eb5643013d835ce3779a5fc208261dbe10f55"
+
+[[package]]
+name = "libc"
+version = "0.2.153"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9c198f91728a82281a64e1f4f9eeb25d82cb32a5de251c6bd1b5154d63a8e7bd"
+
+[[package]]
+name = "libloading"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c571b676ddfc9a8c12f1f3d3085a7b163966a8fd8098a90640953ce5f6170161"
+dependencies = [
+ "cfg-if",
+ "windows-sys",
+]
+
+[[package]]
+name = "log"
+version = "0.4.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b5e6163cb8c49088c2c36f57875e58ccd8c87c7427f7fbd50ea6710b2f3f2e8f"
+
+[[package]]
+name = "magnus"
+version = "0.6.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4778544796676e8428e9c622460ebf284bea52d8b10db3aeb449d8b5e61b3a13"
+dependencies = [
+ "magnus-macros",
+ "rb-sys",
+ "rb-sys-env",
+ "seq-macro",
+]
+
+[[package]]
+name = "magnus-macros"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5968c820e2960565f647819f5928a42d6e874551cab9d88d75e3e0660d7f71e3"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "memchr"
+version = "2.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "523dc4f511e55ab87b694dc30d0f820d60906ef06413f93d4d7a1385599cc149"
+
+[[package]]
+name = "minimal-lexical"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "68354c5c6bd36d73ff3feceb05efa59b6acb7626617f4962be322a825e61f79a"
+
+[[package]]
+name = "nom"
+version = "7.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d273983c5a657a70a3e8f2a01329822f3b8c8172b73826411a55751e404a0a4a"
+dependencies = [
+ "memchr",
+ "minimal-lexical",
+]
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.78"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e2422ad645d89c99f8f3e6b88a9fdeca7fabeac836b1002371c4367c8f984aae"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.35"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "291ec9ab5efd934aaf503a6466c5d5251535d108ee747472c3977cc5acc868ef"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "rb-sys"
+version = "0.9.88"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d11b0965e6df9ef800ac71efc46070960a119f92af1b64d6acd4c357dc139350"
+dependencies = [
+ "rb-sys-build",
+]
+
+[[package]]
+name = "rb-sys-build"
+version = "0.9.88"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c0fce6e53552df8fcd3e4269d7944b0afa38db70d252bbf12caad454caf6d83"
+dependencies = [
+ "bindgen",
+ "lazy_static",
+ "proc-macro2",
+ "quote",
+ "regex",
+ "shell-words",
+ "syn",
+]
+
+[[package]]
+name = "rb-sys-env"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a35802679f07360454b418a5d1735c89716bde01d35b1560fc953c1415a0b3bb"
+
+[[package]]
+name = "rb-sys-test-helpers"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bbd592029353df7955a76ca0b1bf0d9ccc57feab96615f80d1fe756462864949"
+dependencies = [
+ "rb-sys",
+ "rb-sys-env",
+ "rb-sys-test-helpers-macros",
+]
+
+[[package]]
+name = "rb-sys-test-helpers-macros"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c21f156459adb755d58f73dbd783dc1de8b403635e637f7d1daec1c7a920c1f5"
+dependencies = [
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "regex"
+version = "1.10.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b62dbe01f0b06f9d8dc7d49e05a0785f153b00b2c227856282f671e0318c9b15"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-automata",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-automata"
+version = "0.4.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5bb987efffd3c6d0d8f5f89510bb458559eab11e4f869acb20bf845e016259cd"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-syntax"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c08c74e62047bb2de4ff487b251e4a92e24f48745648451635cec7d591162d9f"
+
+[[package]]
+name = "rustc-hash"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2"
+
+[[package]]
+name = "seq-macro"
+version = "0.3.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a3f0bf26fd526d2a95683cd0f87bf103b8539e2ca1ef48ce002d67aad59aa0b4"
+
+[[package]]
+name = "shell-words"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "24188a676b6ae68c3b2cb3a01be17fbf7240ce009799bb56d5b1409051e78fde"
+
+[[package]]
+name = "shlex"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
+
+[[package]]
+name = "sql-insight"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "08f0f793b0e0bff0d2745502e14f8676c62215f42d8c1a82ea2f402d4ad3fb63"
+dependencies = [
+ "sqlparser",
+ "thiserror",
+]
+
+[[package]]
+name = "sql_insight"
+version = "0.1.0"
+dependencies = [
+ "magnus",
+ "rb-sys-test-helpers",
+ "sql-insight",
+]
+
+[[package]]
+name = "sqlparser"
+version = "0.43.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f95c4bae5aba7cd30bd506f7140026ade63cff5afd778af8854026f9606bf5d4"
+dependencies = [
+ "log",
+ "sqlparser_derive",
+]
+
+[[package]]
+name = "sqlparser_derive"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "01b2e185515564f15375f593fb966b5718bc624ba77fe49fa4616ad619690554"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "syn"
+version = "2.0.48"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0f3531638e407dfc0814761abb7c00a5b54992b849452a0646b7f65c9f770f3f"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "thiserror"
+version = "1.0.57"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e45bcbe8ed29775f228095caf2cd67af7a4ccf756ebff23a306bf3e8b47b24b"
+dependencies = [
+ "thiserror-impl",
+]
+
+[[package]]
+name = "thiserror-impl"
+version = "1.0.57"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a953cb265bef375dae3de6663da4d3804eee9682ea80d8e2542529b73c531c81"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3354b9ac3fae1ff6755cb6db53683adb661634f67557942dea4facebec0fee4b"
+
+[[package]]
+name = "windows-sys"
+version = "0.48.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "677d2418bec65e3338edb076e806bc1ec15693c5d0104683f2efe857f61056a9"
+dependencies = [
+ "windows-targets",
+]
+
+[[package]]
+name = "windows-targets"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a2fa6e2155d7247be68c096456083145c183cbbbc2764150dda45a87197940c"
+dependencies = [
+ "windows_aarch64_gnullvm",
+ "windows_aarch64_msvc",
+ "windows_i686_gnu",
+ "windows_i686_msvc",
+ "windows_x86_64_gnu",
+ "windows_x86_64_gnullvm",
+ "windows_x86_64_msvc",
+]
+
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2b38e32f0abccf9987a4e3079dfb67dcd799fb61361e53e2882c3cbaf0d905d8"
+
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc35310971f3b2dbbf3f0690a219f40e2d9afcf64f9ab7cc1be722937c26b4bc"
+
+[[package]]
+name = "windows_i686_gnu"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a75915e7def60c94dcef72200b9a8e58e5091744960da64ec734a6c6e9b3743e"
+
+[[package]]
+name = "windows_i686_msvc"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f55c233f70c4b27f66c523580f78f1004e8b5a8b659e05a4eb49d4166cca406"
+
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "53d40abd2583d23e4718fddf1ebec84dbff8381c07cae67ff7768bbf19c6718e"
+
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b7b52767868a23d5bab768e390dc5f5c55825b6d30b86c844ff2dc7414044cc"
+
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ed94fce61571a4006852b7389a063ab983c02eb1bb37b47f8272ce92d06d9538"

data/Cargo.toml

@@ -0,0 +1,7 @@
+# This Cargo.toml is here to let externals tools (IDEs, etc.) know that this is
+# a Rust project. Your extensions dependencies should be added to the Cargo.toml
+# in the ext/ directory.
+
+[workspace]
+members = ["./ext/sql_insight"]
+resolver = "2"

data/ext/sql_insight/Cargo.toml

@@ -0,0 +1,18 @@
+[package]
+name = "sql_insight"
+version = "0.1.0"
+edition = "2021"
+authors = ["Takahiro Ebato <takahiro.ebato@gmail.com>"]
+license = "MIT"
+publish = false
+
+[lib]
+crate-type = ["cdylib"]
+
+[dependencies]
+magnus = { version = "0.6.2" }
+sql-insight = { version = "0.1.1" }
+
+[dev-dependencies]
+magnus = { version = "0.6.2", features = ["embed"] }
+rb-sys-test-helpers = { version = "0.2" }

data/ext/sql_insight/extconf.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require 'mkmf'
+require 'rb_sys/mkmf'
+
+create_rust_makefile('sql_insight/sql_insight')

data/ext/sql_insight/src/errors.rs

@@ -0,0 +1,37 @@
+use crate::ruby_api::root;
+use magnus::{
+    exception::ExceptionClass, prelude::*, value::Lazy, Error, Ruby,
+};
+
+// define class `SqlInsight::Error < StandardError`
+pub static ERROR: Lazy<ExceptionClass> = Lazy::new(|ruby| {
+    root()
+        .define_error("Error", ruby.exception_standard_error())
+        .unwrap()
+});
+
+// define class `SqlInsight::ParserError < SqlInsight::Error`
+pub static PARSER_ERROR: Lazy<ExceptionClass> = Lazy::new(|ruby| {
+    root()
+        .define_error("ParserError", ruby.get_inner(&ERROR))
+        .unwrap()
+});
+
+// define class `SqlInsight::AnalysisError < SqlInsight::Error`
+pub static ANALYSIS_ERROR: Lazy<ExceptionClass> = Lazy::new(|ruby| {
+    root()
+        .define_error("AnalysisError", ruby.get_inner(&ERROR))
+        .unwrap()
+});
+
+pub fn convert_to_rb_error(ruby: &Ruby, error: sql_insight::error::Error) -> Error {
+    match error {
+        sql_insight::error::Error::ParserError(error) => {
+            Error::new(ruby.get_inner(&PARSER_ERROR), error.to_string())
+        }
+        sql_insight::error::Error::AnalysisError(error) => {
+            Error::new(ruby.get_inner(&ANALYSIS_ERROR), error.to_string())
+        }
+        _ => Error::new(ruby.get_inner(&ERROR), error.to_string()),
+    }
+}

data/ext/sql_insight/src/lib.rs

@@ -0,0 +1,9 @@
+mod errors;
+mod ruby_api;
+
+use magnus::Error;
+
+#[magnus::init]
+fn init() -> Result<(), Error> {
+    ruby_api::init()
+}

data/ext/sql_insight/src/ruby_api/crud_tables.rs

@@ -0,0 +1,147 @@
+use crate::ruby_api::{root, RbTableReference};
+use magnus::{class, function, method, Error, IntoValueFromNative, Module, Object, RArray};
+use sql_insight::CrudTables;
+use std::cell::RefCell;
+
+#[derive(Default, Clone)]
+struct RbCrudTablesInner {
+    create_tables: Vec<RbTableReference>,
+    read_tables: Vec<RbTableReference>,
+    update_tables: Vec<RbTableReference>,
+    delete_tables: Vec<RbTableReference>,
+}
+
+impl RbCrudTablesInner {
+    pub fn new(
+        create_tables: RArray,
+        read_tables: RArray,
+        update_tables: RArray,
+        delete_tables: RArray,
+    ) -> Result<Self, Error> {
+        Ok(Self {
+            create_tables: create_tables.to_vec::<RbTableReference>()?,
+            read_tables: read_tables.to_vec::<RbTableReference>()?,
+            update_tables: update_tables.to_vec::<RbTableReference>()?,
+            delete_tables: delete_tables.to_vec::<RbTableReference>()?,
+        })
+    }
+}
+
+#[magnus::wrap(class = "SqlInsight::CrudTables")]
+pub struct RbCrudTables {
+    inner: RefCell<RbCrudTablesInner>,
+}
+
+unsafe impl IntoValueFromNative for RbCrudTables {}
+
+impl Default for RbCrudTables {
+    fn default() -> Self {
+        Self {
+            inner: RefCell::new(RbCrudTablesInner::default()),
+        }
+    }
+}
+
+impl RbCrudTables {
+    pub fn new(
+        create_tables: RArray,
+        read_tables: RArray,
+        update_tables: RArray,
+        delete_tables: RArray,
+    ) -> Result<Self, Error> {
+        Ok(Self {
+            inner: RefCell::new(RbCrudTablesInner::new(
+                create_tables,
+                read_tables,
+                update_tables,
+                delete_tables,
+            )?),
+        })
+    }
+
+    pub fn from_crud_tables(crud_tables: &CrudTables) -> RbCrudTables {
+        RbCrudTables {
+            inner: RefCell::new(RbCrudTablesInner {
+                create_tables: crud_tables
+                    .create_tables
+                    .iter()
+                    .map(RbTableReference::from_table_reference)
+                    .collect(),
+                read_tables: crud_tables
+                    .read_tables
+                    .iter()
+                    .map(RbTableReference::from_table_reference)
+                    .collect(),
+                update_tables: crud_tables
+                    .update_tables
+                    .iter()
+                    .map(RbTableReference::from_table_reference)
+                    .collect(),
+                delete_tables: crud_tables
+                    .delete_tables
+                    .iter()
+                    .map(RbTableReference::from_table_reference)
+                    .collect(),
+            }),
+        }
+    }
+
+    fn create_tables(&self) -> RArray {
+        RArray::from_vec(self.inner.borrow().create_tables.clone())
+    }
+
+    fn set_create_tables(&self, create_tables: RArray) -> Result<(), Error> {
+        self.inner.borrow_mut().create_tables = create_tables.to_vec::<RbTableReference>()?;
+        Ok(())
+    }
+
+    fn read_tables(&self) -> RArray {
+        RArray::from_vec(self.inner.borrow().read_tables.clone())
+    }
+
+    fn set_read_tables(&self, read_tables: RArray) -> Result<(), Error> {
+        self.inner.borrow_mut().read_tables = read_tables.to_vec::<RbTableReference>()?;
+        Ok(())
+    }
+
+    fn update_tables(&self) -> RArray {
+        RArray::from_vec(self.inner.borrow().update_tables.clone())
+    }
+
+    fn set_update_tables(&self, update_tables: RArray) -> Result<(), Error> {
+        self.inner.borrow_mut().update_tables = update_tables.to_vec::<RbTableReference>()?;
+        Ok(())
+    }
+
+    fn delete_tables(&self) -> RArray {
+        RArray::from_vec(self.inner.borrow().delete_tables.clone())
+    }
+
+    fn set_delete_tables(&self, delete_tables: RArray) -> Result<(), Error> {
+        self.inner.borrow_mut().delete_tables = delete_tables.to_vec::<RbTableReference>()?;
+        Ok(())
+    }
+}
+
+pub fn init() -> Result<(), Error> {
+    let class = root().define_class("CrudTables", class::object())?;
+    class.define_singleton_method("new", function!(RbCrudTables::new, 4))?;
+    class.define_method("create_tables", method!(RbCrudTables::create_tables, 0))?;
+    class.define_method(
+        "create_tables=",
+        method!(RbCrudTables::set_create_tables, 1),
+    )?;
+    class.define_method("read_tables", method!(RbCrudTables::read_tables, 0))?;
+    class.define_method("read_tables=", method!(RbCrudTables::set_read_tables, 1))?;
+    class.define_method("update_tables", method!(RbCrudTables::update_tables, 0))?;
+    class.define_method(
+        "update_tables=",
+        method!(RbCrudTables::set_update_tables, 1),
+    )?;
+    class.define_method("delete_tables", method!(RbCrudTables::delete_tables, 0))?;
+    class.define_method(
+        "delete_tables=",
+        method!(RbCrudTables::set_delete_tables, 1),
+    )?;
+    Ok(())
+}

data/ext/sql_insight/src/ruby_api/ident.rs

@@ -0,0 +1,85 @@
+use crate::ruby_api::root;
+use core::fmt;
+use magnus::value::ReprValue;
+use magnus::{class, function, method, Error, Module, Object, TryConvert};
+use sql_insight::sqlparser::ast::Ident;
+use std::cell::RefCell;
+
+#[derive(Clone)]
+#[magnus::wrap(class = "SqlInsight::Ident")]
+pub struct RbIdent {
+    pub inner: RefCell<Ident>,
+}
+
+impl TryConvert for RbIdent {
+    fn try_convert(val: magnus::Value) -> Result<Self, Error> {
+        Ok(Self {
+            inner: RefCell::new(Ident {
+                value: val.funcall("value", ())?,
+                quote_style: val.funcall("quote_style", ())?,
+            }),
+        })
+    }
+}
+
+impl Default for RbIdent {
+    fn default() -> Self {
+        Self {
+            inner: RefCell::new(Ident::new(String::new())),
+        }
+    }
+}
+
+impl fmt::Display for RbIdent {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}", self.inner.borrow())
+    }
+}
+
+impl RbIdent {
+    pub fn new(value: String, quote: Option<char>) -> Self {
+        Self {
+            inner: RefCell::new(Ident {
+                value,
+                quote_style: quote,
+            }),
+        }
+    }
+
+    pub fn from_ident(ident: &Ident) -> Self {
+        Self {
+            inner: RefCell::new(ident.clone()),
+        }
+    }
+
+    fn value(&self) -> String {
+        self.inner.borrow().value.clone()
+    }
+
+    fn set_value(&self, value: String) {
+        self.inner.borrow_mut().value = value;
+    }
+
+    fn quote_style(&self) -> Option<char> {
+        self.inner.borrow().quote_style
+    }
+
+    fn set_quote_style(&self, quote_style: Option<char>) {
+        self.inner.borrow_mut().quote_style = quote_style;
+    }
+
+    fn to_s(&self) -> String {
+        self.inner.borrow().to_string()
+    }
+}
+
+pub fn init() -> Result<(), Error> {
+    let class = root().define_class("Ident", class::object())?;
+    class.define_singleton_method("new", function!(RbIdent::new, 2))?;
+    class.define_method("value", method!(RbIdent::value, 0))?;
+    class.define_method("value=", method!(RbIdent::set_value, 1))?;
+    class.define_method("quote_style", method!(RbIdent::quote_style, 0))?;
+    class.define_method("quote_style=", method!(RbIdent::set_quote_style, 1))?;
+    class.define_method("to_s", method!(RbIdent::to_s, 0))?;
+    Ok(())
+}

data/ext/sql_insight/src/ruby_api/mod.rs

@@ -0,0 +1,29 @@
+use magnus::value::Lazy;
+use magnus::{Error, RModule, Ruby};
+
+mod crud_tables;
+mod ident;
+mod pub_funcs;
+mod table_reference;
+mod tables;
+
+pub use crud_tables::RbCrudTables;
+
+pub use table_reference::RbTableReference;
+pub use tables::RbTables;
+
+pub fn root() -> RModule {
+    static ROOT: Lazy<RModule> = Lazy::new(|ruby| ruby.define_module("SqlInsight").unwrap());
+    let ruby = Ruby::get().unwrap();
+    ruby.get_inner(&ROOT)
+}
+
+pub fn init() -> Result<(), Error> {
+    ident::init()?;
+    table_reference::init()?;
+    tables::init()?;
+    crud_tables::init()?;
+    pub_funcs::init()?;
+
+    Ok(())
+}

data/ext/sql_insight/src/ruby_api/pub_funcs.rs

@@ -0,0 +1,79 @@
+use crate::errors::{convert_to_rb_error};
+use crate::ruby_api::root;
+use crate::ruby_api::{RbCrudTables, RbTables};
+use magnus::{exception, function, Error, Object, RArray, Ruby};
+use sql_insight::sqlparser::dialect;
+use sql_insight::sqlparser::dialect::Dialect;
+use sql_insight::NormalizerOptions;
+
+fn get_dialect(dialect_name: &str) -> Result<Box<dyn Dialect>, Error> {
+    dialect::dialect_from_str(dialect_name).ok_or_else(|| {
+        Error::new(
+            exception::arg_error(),
+            format!("Unknown dialect: {}", dialect_name),
+        )
+    })
+}
+
+pub fn rb_format(ruby: &Ruby, dialect_name: String, sql: String) -> Result<Vec<String>, Error> {
+    match sql_insight::format(get_dialect(dialect_name.as_str())?.as_ref(), sql.as_str()) {
+        Ok(result) => Ok(result),
+        Err(error) => Err(convert_to_rb_error(ruby, error)),
+    }
+}
+
+fn rb_normalize(ruby: &Ruby, dialect_name: String, sql: String) -> Result<Vec<String>, Error> {
+    match sql_insight::normalize_with_options(
+        get_dialect(dialect_name.as_str())?.as_ref(),
+        sql.as_str(),
+        NormalizerOptions::new(),
+    ) {
+        Ok(result) => Ok(result),
+        Err(error) => Err(convert_to_rb_error(ruby, error)),
+    }
+}
+
+fn rb_extract_tables(ruby: &Ruby, dialect_name: String, sql: String) -> Result<RArray, Error> {
+    match sql_insight::extract_tables(get_dialect(dialect_name.as_str())?.as_ref(), sql.as_str()) {
+        Ok(result) => {
+            let mut results_of_tables = vec![];
+            for tables in result {
+                match tables {
+                    Ok(tables) => results_of_tables.push(RbTables::from_tables(&tables)),
+                    Err(error) => return Err(convert_to_rb_error(ruby, error)),
+                }
+            }
+            Ok(RArray::from_vec(results_of_tables))
+        }
+        Err(error) => Err(convert_to_rb_error(ruby, error)),
+    }
+}
+
+fn rb_extract_crud_tables(ruby: &Ruby, dialect_name: String, sql: String) -> Result<RArray, Error> {
+    match sql_insight::extract_crud_tables(
+        get_dialect(dialect_name.as_str())?.as_ref(),
+        sql.as_str(),
+    ) {
+        Ok(result) => {
+            let mut results_of_crud_tables = vec![];
+            for crud_tables in result {
+                match crud_tables {
+                    Ok(crud_tables) => {
+                        results_of_crud_tables.push(RbCrudTables::from_crud_tables(&crud_tables))
+                    }
+                    Err(error) => return Err(convert_to_rb_error(ruby, error)),
+                }
+            }
+            Ok(RArray::from_vec(results_of_crud_tables))
+        }
+        Err(error) => Err(convert_to_rb_error(ruby, error)),
+    }
+}
+
+pub fn init() -> Result<(), Error> {
+    root().define_singleton_method("format", function!(rb_format, 2))?;
+    root().define_singleton_method("normalize", function!(rb_normalize, 2))?;
+    root().define_singleton_method("extract_tables", function!(rb_extract_tables, 2))?;
+    root().define_singleton_method("extract_crud_tables", function!(rb_extract_crud_tables, 2))?;
+    Ok(())
+}

data/ext/sql_insight/src/ruby_api/table_reference.rs

@@ -0,0 +1,176 @@
+use crate::ruby_api::ident::RbIdent;
+
+use core::fmt;
+use std::cell::RefCell;
+
+use crate::ruby_api::root;
+use magnus::try_convert::TryConvertOwned;
+use magnus::value::ReprValue;
+use magnus::{
+    class, function, method, Error, IntoValueFromNative, Module, Object, RClass, TryConvert, Value,
+};
+use sql_insight::TableReference;
+
+#[derive(Default, Clone)]
+pub struct RbTableReferenceInner {
+    catalog: Option<RbIdent>,
+    schema: Option<RbIdent>,
+    name: RbIdent,
+    alias: Option<RbIdent>,
+}
+
+impl TryConvert for RbTableReferenceInner {
+    fn try_convert(val: Value) -> Result<Self, Error> {
+        if val.is_kind_of(root().const_get::<_, RClass>("TableReference")?) {
+            Ok(Self {
+                catalog: val.funcall("catalog", ())?,
+                schema: val.funcall("schema", ())?,
+                name: val.funcall("name", ())?,
+                alias: val.funcall("alias", ())?,
+            })
+        } else {
+            Err(Error::new(
+                magnus::exception::type_error(),
+                format!(
+                    "No implicit conversion of {} into SqlInsight::TableReference",
+                    val.class()
+                ),
+            ))
+        }
+    }
+}
+
+impl fmt::Display for RbTableReferenceInner {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let mut parts = Vec::new();
+        if let Some(catalog) = &self.catalog {
+            parts.push(catalog.to_string());
+        }
+        if let Some(schema) = &self.schema {
+            parts.push(schema.to_string());
+        }
+        parts.push(self.name.to_string());
+        let table = parts.join(".");
+        if let Some(alias) = &self.alias {
+            write!(f, "{} AS {}", table, alias)
+        } else {
+            write!(f, "{}", table)
+        }
+    }
+}
+
+#[derive(Clone)]
+#[magnus::wrap(class = "SqlInsight::TableReference")]
+pub struct RbTableReference {
+    inner: RefCell<RbTableReferenceInner>,
+}
+
+impl TryConvert for RbTableReference {
+    fn try_convert(val: Value) -> Result<Self, Error> {
+        Ok(Self {
+            inner: RefCell::new(RbTableReferenceInner::try_convert(val)?),
+        })
+    }
+}
+
+unsafe impl TryConvertOwned for RbTableReference {}
+
+unsafe impl IntoValueFromNative for RbTableReference {}
+
+impl Default for RbTableReference {
+    fn default() -> Self {
+        Self {
+            inner: RefCell::new(RbTableReferenceInner::default()),
+        }
+    }
+}
+
+impl RbTableReference {
+    pub fn new(
+        catalog: Option<&RbIdent>,
+        schema: Option<&RbIdent>,
+        name: &RbIdent,
+        alias: Option<&RbIdent>,
+    ) -> Self {
+        Self {
+            inner: RbTableReferenceInner {
+                catalog: catalog.cloned(),
+                schema: schema.cloned(),
+                name: name.clone(),
+                alias: alias.cloned(),
+            }
+            .into(),
+        }
+    }
+
+    pub fn from_table_reference(table_reference: &TableReference) -> Self {
+        Self {
+            inner: RefCell::new(RbTableReferenceInner {
+                catalog: table_reference
+                    .catalog
+                    .clone()
+                    .map(|ident| RbIdent::from_ident(&ident)),
+                schema: table_reference
+                    .schema
+                    .clone()
+                    .map(|ident| RbIdent::from_ident(&ident)),
+                name: RbIdent::from_ident(&table_reference.name),
+                alias: table_reference
+                    .alias
+                    .clone()
+                    .map(|ident| RbIdent::from_ident(&ident)),
+            }),
+        }
+    }
+
+    fn catalog(&self) -> Option<RbIdent> {
+        self.inner.borrow().catalog.clone()
+    }
+
+    fn set_catalog(&self, catalog: Option<&RbIdent>) {
+        self.inner.borrow_mut().catalog = catalog.cloned();
+    }
+
+    fn schema(&self) -> Option<RbIdent> {
+        self.inner.borrow().schema.clone()
+    }
+
+    fn set_schema(&self, schema: Option<&RbIdent>) {
+        self.inner.borrow_mut().schema = schema.cloned();
+    }
+
+    fn name(&self) -> RbIdent {
+        self.inner.borrow().name.clone()
+    }
+
+    fn set_name(&self, name: &RbIdent) {
+        self.inner.borrow_mut().name = name.clone();
+    }
+
+    fn alias(&self) -> Option<RbIdent> {
+        self.inner.borrow().alias.clone()
+    }
+
+    fn set_alias(&self, alias: Option<&RbIdent>) {
+        self.inner.borrow_mut().alias = alias.cloned();
+    }
+
+    fn to_s(&self) -> String {
+        self.inner.borrow().to_string()
+    }
+}
+
+pub fn init() -> Result<(), Error> {
+    let class = root().define_class("TableReference", class::object())?;
+    class.define_singleton_method("new", function!(RbTableReference::new, 4))?;
+    class.define_method("catalog", method!(RbTableReference::catalog, 0))?;
+    class.define_method("catalog=", method!(RbTableReference::set_catalog, 1))?;
+    class.define_method("schema", method!(RbTableReference::schema, 0))?;
+    class.define_method("schema=", method!(RbTableReference::set_schema, 1))?;
+    class.define_method("name", method!(RbTableReference::name, 0))?;
+    class.define_method("name=", method!(RbTableReference::set_name, 1))?;
+    class.define_method("alias", method!(RbTableReference::alias, 0))?;
+    class.define_method("alias=", method!(RbTableReference::set_alias, 1))?;
+    class.define_method("to_s", method!(RbTableReference::to_s, 0))?;
+    Ok(())
+}

data/ext/sql_insight/src/ruby_api/tables.rs

@@ -0,0 +1,69 @@
+use crate::ruby_api::{root, RbTableReference};
+use magnus::{class, function, method, Error, IntoValueFromNative, Module, Object, RArray};
+use sql_insight::Tables;
+use std::cell::RefCell;
+
+#[derive(Default, Clone)]
+struct RbTablesInner {
+    tables: Vec<RbTableReference>,
+}
+
+impl RbTablesInner {
+    pub fn new(tables: RArray) -> Result<Self, Error> {
+        Ok(Self {
+            tables: tables.to_vec::<RbTableReference>()?,
+        })
+    }
+}
+
+#[magnus::wrap(class = "SqlInsight::Tables")]
+pub struct RbTables {
+    inner: RefCell<RbTablesInner>,
+}
+
+unsafe impl IntoValueFromNative for RbTables {}
+
+impl Default for RbTables {
+    fn default() -> Self {
+        Self {
+            inner: RefCell::new(RbTablesInner::default()),
+        }
+    }
+}
+
+impl RbTables {
+    pub fn new(tables: RArray) -> Result<Self, Error> {
+        Ok(Self {
+            inner: RefCell::new(RbTablesInner::new(tables)?),
+        })
+    }
+
+    pub fn from_tables(tables: &Tables) -> RbTables {
+        RbTables {
+            inner: RefCell::new(RbTablesInner {
+                tables: tables
+                    .0
+                    .iter()
+                    .map(RbTableReference::from_table_reference)
+                    .collect(),
+            }),
+        }
+    }
+
+    fn tables(&self) -> RArray {
+        RArray::from_vec(self.inner.borrow().tables.clone())
+    }
+
+    fn set_tables(&self, tables: RArray) -> Result<(), Error> {
+        self.inner.borrow_mut().tables = tables.to_vec::<RbTableReference>()?;
+        Ok(())
+    }
+}
+
+pub fn init() -> Result<(), Error> {
+    let class = root().define_class("Tables", class::object())?;
+    class.define_singleton_method("new", function!(RbTables::new, 1))?;
+    class.define_method("tables", method!(RbTables::tables, 0))?;
+    class.define_method("tables=", method!(RbTables::set_tables, 1))?;
+    Ok(())
+}

data/lib/sql_insight/dialect.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+module SqlInsight
+  module Dialect
+    MYSQL = 'MySQL'
+    POSTGRESQL = 'PostgreSQL'
+    SQLITE = 'SQLite'
+    SQLSERVER = 'MsSQL'
+    GENERIC = 'Generic'
+    HIVE = 'Hive'
+    SNOWFLAKE = 'Snowflake'
+    REDSHIFT = 'Uedshift'
+    CLICKHOUSE = 'Clickhouse'
+    BIGQUERY = 'BigQuery'
+    ANSI = 'ANSI'
+    DUCKDB = 'DuckDB'
+  end
+end

data/lib/sql_insight/errors.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+# Definitions must be synced with ext/sql_insight/src/errors.rs
+module SqlInsight
+  class Error < StandardError
+  end
+
+  class ParserError < Error
+  end
+
+  class AnalysisError < Error
+  end
+end

data/lib/sql_insight/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module SqlInsight
+  VERSION = '0.1.0.alpha.1'
+end

data/lib/sql_insight.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative 'sql_insight/version'
+require_relative 'sql_insight/dialect'
+require_relative 'sql_insight/errors'
+
+# https://github.com/rake-compiler/rake-compiler/blob/master/README.md
+# Technique to lookup the fat binaries first, and then lookup the gems compiled by the end user.
+begin
+  RUBY_VERSION =~ /(\d+\.\d+)/
+  require_relative "sql_insight/#{Regexp.last_match(1)}/sql_insight"
+rescue LoadError
+  require_relative 'sql_insight/sql_insight'
+end
+
+module SqlInsight
+end

metadata

@@ -0,0 +1,79 @@
+--- !ruby/object:Gem::Specification
+name: sql_insight
+version: !ruby/object:Gem::Version
+  version: 0.1.0.alpha.1
+platform: ruby
+authors:
+- Takahiro Ebato
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2024-03-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rb_sys
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.90
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.90
+description: Ruby bindings for the sql-insight, a utility for SQL query analysis and
+  transformation supporting various SQL dialects
+email:
+- takahiro.ebato@gmail.com
+executables: []
+extensions:
+- ext/sql_insight/extconf.rb
+extra_rdoc_files: []
+files:
+- Cargo.lock
+- Cargo.toml
+- ext/sql_insight/Cargo.toml
+- ext/sql_insight/extconf.rb
+- ext/sql_insight/src/errors.rs
+- ext/sql_insight/src/lib.rs
+- ext/sql_insight/src/ruby_api/crud_tables.rs
+- ext/sql_insight/src/ruby_api/ident.rs
+- ext/sql_insight/src/ruby_api/mod.rs
+- ext/sql_insight/src/ruby_api/pub_funcs.rs
+- ext/sql_insight/src/ruby_api/table_reference.rs
+- ext/sql_insight/src/ruby_api/tables.rs
+- lib/sql_insight.rb
+- lib/sql_insight/dialect.rb
+- lib/sql_insight/errors.rb
+- lib/sql_insight/version.rb
+homepage: https://github.com/takaebato/sql-insight-rb
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/takaebato/sql-insight-rb
+  source_code_uri: https://github.com/takaebato/sql-insight-rb
+  changelog_uri: https://github.com/takaebato/sql-insight-rb/blob/master/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.2
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.3.22
+requirements: []
+rubygems_version: 3.5.3
+signing_key:
+specification_version: 4
+summary: Ruby bindings for the sql-insight, a utility for SQL query analysis and transformation
+test_files: []