polyglot-sql 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 23c2e1649bd1bbecd604bda51f8ba41f91e43cfb62a31b90a9ab8a9e351c9157
+  data.tar.gz: 1bc16150dd37f2126f08b67716df2dbbf62d6d17416e23c9da374b834d140d46
+SHA512:
+  metadata.gz: 3dd316989daa3328c44627dac6b6c7922f023d0c2883584bda1e23e68a43d4c9efde271ff10c5ab4b90b43ba935aaae872c599e4fd9bb7273328a1a1141891de
+  data.tar.gz: b14f936805c04980ff56be1b1c04c10dfb47499d2e0344c2ac113d51ab1e36e1ba5485ce9f1103a8b757c58ce7e30591f1f76ce64a0dba66e65e2dce6fff6d94

data/Cargo.toml

@@ -0,0 +1,9 @@
+[workspace]
+members = ["ext/polyglot_rb"]
+resolver = "2"
+
+[profile.release]
+strip = true
+
+[profile.dev]
+strip = true

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Chris Atkins
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,136 @@
+# polyglot-sql
+
+[![Build status](https://badge.buildkite.com/e9b6acd7cb9addaa60ca20a96e74f3934285e9ccbd969358f2.svg)](https://buildkite.com/catkins-test/polyglot-sql-rb)
+
+Ruby bindings for [polyglot-sql](https://github.com/tobilg/polyglot) — a Rust-based SQL transpiler supporting 30+ database dialects.
+
+## Installation
+
+Add to your Gemfile:
+
+```ruby
+gem "polyglot-sql"
+```
+
+Requires Rust toolchain for compilation. Install via [rustup](https://rustup.rs/).
+
+## Usage
+
+### Transpile SQL Between Dialects
+
+```ruby
+require "polyglot"
+
+# PostgreSQL to MySQL
+Polyglot.transpile("SELECT NOW()", from: :postgres, to: :mysql)
+# => ["SELECT CURRENT_TIMESTAMP()"]
+
+# PostgreSQL to Snowflake
+Polyglot.transpile("SELECT CAST(x AS TEXT)", from: :postgres, to: :snowflake)
+# => ["SELECT CAST(x AS TEXT)"]
+```
+
+### Parse SQL to AST
+
+```ruby
+ast = Polyglot.parse("SELECT 1", dialect: :postgres)
+# => [{"select" => {...}}]
+
+ast = Polyglot.parse_one("SELECT 1", dialect: :postgres)
+# => {"select" => {...}}
+```
+
+### Generate SQL from AST
+
+```ruby
+ast = Polyglot.parse_one("SELECT 1", dialect: :postgres)
+Polyglot.generate(ast, dialect: :mysql)
+# => "SELECT 1"
+```
+
+### Format SQL
+
+```ruby
+Polyglot.format("SELECT a, b FROM t WHERE x = 1", dialect: :postgres)
+```
+
+### Validate SQL
+
+```ruby
+result = Polyglot.validate("SELECT 1", dialect: :postgres)
+result.valid?  # => true
+result.errors  # => []
+
+result = Polyglot.validate("SELEC 1")
+result.valid?  # => false
+result.errors.first.message  # => "..."
+```
+
+### List Supported Dialects
+
+```ruby
+Polyglot.dialects
+# => ["generic", "athena", "bigquery", "clickhouse", ..., "tsql"]
+```
+
+## Supported Dialects
+
+<!-- SUPPORTED_DIALECTS:START -->
+- Generic
+- Athena
+- BigQuery
+- ClickHouse
+- CockroachDB
+- Databricks
+- Doris
+- Dremio
+- Drill
+- Druid
+- DuckDB
+- Dune
+- Exasol
+- Fabric
+- Hive
+- Materialize
+- MySQL
+- Oracle
+- PostgreSQL
+- Presto
+- Redshift
+- RisingWave
+- SingleStore
+- Snowflake
+- Solr
+- Spark
+- SQLite
+- StarRocks
+- Tableau
+- Teradata
+- TiDB
+- Trino
+- T-SQL
+<!-- SUPPORTED_DIALECTS:END -->
+
+## Error Handling
+
+```ruby
+Polyglot::Error            # Base error class
+Polyglot::ParseError       # SQL parsing errors
+Polyglot::GenerateError    # SQL generation errors
+Polyglot::UnsupportedError # Unsupported dialect features
+```
+
+## Development
+
+```bash
+bundle install
+bundle exec rake          # compile + test
+bundle exec rake compile  # compile only
+bundle exec rake spec     # test only
+bundle exec standardrb    # lint
+bundle exec rake docs:dialects  # sync README dialect list
+```
+
+## License
+
+MIT

data/ext/polyglot_rb/Cargo.toml

@@ -0,0 +1,17 @@
+[package]
+name = "polyglot_rb"
+version = "0.1.0"
+edition = "2021"
+publish = false
+license = "MIT"
+description = "Ruby bindings for polyglot-sql transpiler"
+
+[lib]
+name = "polyglot_rb"
+crate-type = ["cdylib"]
+
+[dependencies]
+polyglot-sql = "0.1"
+magnus = { version = "0.8", features = ["rb-sys"] }
+rb-sys = { version = "0.9", features = ["stable-api-compiled-fallback"] }
+serde_json = "1.0"

data/ext/polyglot_rb/extconf.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require "mkmf"
+require "rb_sys/mkmf"
+
+create_rust_makefile("polyglot/polyglot_rb")

data/ext/polyglot_rb/src/dialect.rs

@@ -0,0 +1,199 @@
+use magnus::{Error, Ruby};
+use polyglot_sql::dialects::DialectType;
+
+struct DialectSpec {
+    canonical: &'static str,
+    dialect: DialectType,
+    aliases: &'static [&'static str],
+}
+
+const DIALECT_SPECS: &[DialectSpec] = &[
+    DialectSpec {
+        canonical: "generic",
+        dialect: DialectType::Generic,
+        aliases: &[],
+    },
+    DialectSpec {
+        canonical: "athena",
+        dialect: DialectType::Athena,
+        aliases: &[],
+    },
+    DialectSpec {
+        canonical: "bigquery",
+        dialect: DialectType::BigQuery,
+        aliases: &[],
+    },
+    DialectSpec {
+        canonical: "clickhouse",
+        dialect: DialectType::ClickHouse,
+        aliases: &[],
+    },
+    DialectSpec {
+        canonical: "cockroachdb",
+        dialect: DialectType::CockroachDB,
+        aliases: &[],
+    },
+    DialectSpec {
+        canonical: "databricks",
+        dialect: DialectType::Databricks,
+        aliases: &[],
+    },
+    DialectSpec {
+        canonical: "doris",
+        dialect: DialectType::Doris,
+        aliases: &[],
+    },
+    DialectSpec {
+        canonical: "dremio",
+        dialect: DialectType::Dremio,
+        aliases: &[],
+    },
+    DialectSpec {
+        canonical: "drill",
+        dialect: DialectType::Drill,
+        aliases: &[],
+    },
+    DialectSpec {
+        canonical: "druid",
+        dialect: DialectType::Druid,
+        aliases: &[],
+    },
+    DialectSpec {
+        canonical: "duckdb",
+        dialect: DialectType::DuckDB,
+        aliases: &[],
+    },
+    DialectSpec {
+        canonical: "dune",
+        dialect: DialectType::Dune,
+        aliases: &[],
+    },
+    DialectSpec {
+        canonical: "exasol",
+        dialect: DialectType::Exasol,
+        aliases: &[],
+    },
+    DialectSpec {
+        canonical: "fabric",
+        dialect: DialectType::Fabric,
+        aliases: &[],
+    },
+    DialectSpec {
+        canonical: "hive",
+        dialect: DialectType::Hive,
+        aliases: &[],
+    },
+    DialectSpec {
+        canonical: "materialize",
+        dialect: DialectType::Materialize,
+        aliases: &[],
+    },
+    DialectSpec {
+        canonical: "mysql",
+        dialect: DialectType::MySQL,
+        aliases: &[],
+    },
+    DialectSpec {
+        canonical: "oracle",
+        dialect: DialectType::Oracle,
+        aliases: &[],
+    },
+    DialectSpec {
+        canonical: "postgres",
+        dialect: DialectType::PostgreSQL,
+        aliases: &["postgresql"],
+    },
+    DialectSpec {
+        canonical: "presto",
+        dialect: DialectType::Presto,
+        aliases: &[],
+    },
+    DialectSpec {
+        canonical: "redshift",
+        dialect: DialectType::Redshift,
+        aliases: &[],
+    },
+    DialectSpec {
+        canonical: "risingwave",
+        dialect: DialectType::RisingWave,
+        aliases: &[],
+    },
+    DialectSpec {
+        canonical: "singlestore",
+        dialect: DialectType::SingleStore,
+        aliases: &[],
+    },
+    DialectSpec {
+        canonical: "snowflake",
+        dialect: DialectType::Snowflake,
+        aliases: &[],
+    },
+    DialectSpec {
+        canonical: "solr",
+        dialect: DialectType::Solr,
+        aliases: &[],
+    },
+    DialectSpec {
+        canonical: "spark",
+        dialect: DialectType::Spark,
+        aliases: &[],
+    },
+    DialectSpec {
+        canonical: "sqlite",
+        dialect: DialectType::SQLite,
+        aliases: &[],
+    },
+    DialectSpec {
+        canonical: "starrocks",
+        dialect: DialectType::StarRocks,
+        aliases: &[],
+    },
+    DialectSpec {
+        canonical: "tableau",
+        dialect: DialectType::Tableau,
+        aliases: &[],
+    },
+    DialectSpec {
+        canonical: "teradata",
+        dialect: DialectType::Teradata,
+        aliases: &[],
+    },
+    DialectSpec {
+        canonical: "tidb",
+        dialect: DialectType::TiDB,
+        aliases: &[],
+    },
+    DialectSpec {
+        canonical: "trino",
+        dialect: DialectType::Trino,
+        aliases: &[],
+    },
+    DialectSpec {
+        canonical: "tsql",
+        dialect: DialectType::TSQL,
+        aliases: &[],
+    },
+];
+
+pub fn dialect_from_name(name: &str) -> Result<DialectType, Error> {
+    let normalized = name.to_lowercase().replace(['-', '_'], "");
+
+    for spec in DIALECT_SPECS {
+        if spec.canonical == normalized || spec.aliases.contains(&normalized.as_str()) {
+            return Ok(spec.dialect);
+        }
+    }
+
+    let ruby = Ruby::get().expect("Ruby runtime not available");
+    Err(Error::new(
+        ruby.exception_arg_error(),
+        format!("unknown dialect: '{}'. Use Polyglot.dialects to see supported dialects", name),
+    ))
+}
+
+pub fn dialect_names() -> Vec<String> {
+    DIALECT_SPECS
+        .iter()
+        .map(|spec| spec.canonical.to_string())
+        .collect()
+}

data/ext/polyglot_rb/src/errors.rs

@@ -0,0 +1,100 @@
+use magnus::{Error, ExceptionClass, Module, Ruby};
+use std::cell::RefCell;
+
+thread_local! {
+    static POLYGLOT_ERROR: RefCell<Option<ExceptionClass>> = const { RefCell::new(None) };
+    static PARSE_ERROR: RefCell<Option<ExceptionClass>> = const { RefCell::new(None) };
+    static GENERATE_ERROR: RefCell<Option<ExceptionClass>> = const { RefCell::new(None) };
+    static UNSUPPORTED_ERROR: RefCell<Option<ExceptionClass>> = const { RefCell::new(None) };
+}
+
+pub fn define_exceptions(ruby: &Ruby, module: &magnus::RModule) -> Result<(), Error> {
+    let standard_error = ruby.exception_standard_error();
+
+    let polyglot_error = module.define_error("Error", standard_error)?;
+    POLYGLOT_ERROR.with(|cell| {
+        *cell.borrow_mut() = Some(polyglot_error);
+    });
+
+    let parse_error = module.define_error("ParseError", polyglot_error)?;
+    PARSE_ERROR.with(|cell| {
+        *cell.borrow_mut() = Some(parse_error);
+    });
+
+    let generate_error = module.define_error("GenerateError", polyglot_error)?;
+    GENERATE_ERROR.with(|cell| {
+        *cell.borrow_mut() = Some(generate_error);
+    });
+
+    let unsupported_error = module.define_error("UnsupportedError", polyglot_error)?;
+    UNSUPPORTED_ERROR.with(|cell| {
+        *cell.borrow_mut() = Some(unsupported_error);
+    });
+
+    Ok(())
+}
+
+pub fn polyglot_error(message: String) -> Error {
+    POLYGLOT_ERROR.with(|cell| {
+        let class = cell.borrow();
+        match class.as_ref() {
+            Some(cls) => Error::new(*cls, message),
+            None => {
+                let ruby = Ruby::get().expect("Ruby runtime not available");
+                Error::new(ruby.exception_runtime_error(), message)
+            }
+        }
+    })
+}
+
+pub fn parse_error(message: String) -> Error {
+    PARSE_ERROR.with(|cell| {
+        let class = cell.borrow();
+        match class.as_ref() {
+            Some(cls) => Error::new(*cls, message),
+            None => {
+                let ruby = Ruby::get().expect("Ruby runtime not available");
+                Error::new(ruby.exception_runtime_error(), message)
+            }
+        }
+    })
+}
+
+pub fn generate_error(message: String) -> Error {
+    GENERATE_ERROR.with(|cell| {
+        let class = cell.borrow();
+        match class.as_ref() {
+            Some(cls) => Error::new(*cls, message),
+            None => {
+                let ruby = Ruby::get().expect("Ruby runtime not available");
+                Error::new(ruby.exception_runtime_error(), message)
+            }
+        }
+    })
+}
+
+pub fn unsupported_error(message: String) -> Error {
+    UNSUPPORTED_ERROR.with(|cell| {
+        let class = cell.borrow();
+        match class.as_ref() {
+            Some(cls) => Error::new(*cls, message),
+            None => {
+                let ruby = Ruby::get().expect("Ruby runtime not available");
+                Error::new(ruby.exception_runtime_error(), message)
+            }
+        }
+    })
+}
+
+pub fn map_polyglot_error(err: polyglot_sql::error::Error) -> Error {
+    let message = err.to_string();
+
+    match err {
+        polyglot_sql::error::Error::Parse(..) => parse_error(message),
+        polyglot_sql::error::Error::Tokenize { .. } => parse_error(message),
+        polyglot_sql::error::Error::Syntax { .. } => parse_error(message),
+        polyglot_sql::error::Error::Generate(..) => generate_error(message),
+        polyglot_sql::error::Error::Unsupported { .. } => unsupported_error(message),
+        polyglot_sql::error::Error::Internal(..) => polyglot_error(message),
+    }
+}

data/ext/polyglot_rb/src/lib.rs

@@ -0,0 +1,108 @@
+use magnus::{function, Error, Object, RArray, Ruby};
+
+mod dialect;
+mod errors;
+
+fn transpile(sql: String, from: String, to: String) -> Result<RArray, Error> {
+    let ruby = Ruby::get().expect("Ruby runtime not available");
+    let from_dialect = dialect::dialect_from_name(&from)?;
+    let to_dialect = dialect::dialect_from_name(&to)?;
+
+    let results = polyglot_sql::transpile(&sql, from_dialect, to_dialect)
+        .map_err(errors::map_polyglot_error)?;
+
+    let arr = ruby.ary_new_capa(results.len());
+    for s in results {
+        arr.push(ruby.str_new(&s))?;
+    }
+    Ok(arr)
+}
+
+fn parse(sql: String, dialect_name: String) -> Result<String, Error> {
+    let dialect_type = dialect::dialect_from_name(&dialect_name)?;
+
+    let expressions = polyglot_sql::parse(&sql, dialect_type)
+        .map_err(errors::map_polyglot_error)?;
+
+    serde_json::to_string(&expressions)
+        .map_err(|e| errors::polyglot_error(format!("JSON serialization error: {e}")))
+}
+
+fn parse_one(sql: String, dialect_name: String) -> Result<String, Error> {
+    let dialect_type = dialect::dialect_from_name(&dialect_name)?;
+
+    let expression = polyglot_sql::parse_one(&sql, dialect_type)
+        .map_err(errors::map_polyglot_error)?;
+
+    serde_json::to_string(&expression)
+        .map_err(|e| errors::polyglot_error(format!("JSON serialization error: {e}")))
+}
+
+fn generate(ast_json: String, dialect_name: String) -> Result<String, Error> {
+    let dialect_type = dialect::dialect_from_name(&dialect_name)?;
+
+    let expression: polyglot_sql::expressions::Expression = serde_json::from_str(&ast_json)
+        .map_err(|e| {
+            errors::generate_error(format!(
+                "Invalid AST JSON for SQL generation at line {}, column {}",
+                e.line(),
+                e.column()
+            ))
+        })?;
+
+    polyglot_sql::generate(&expression, dialect_type)
+        .map_err(errors::map_polyglot_error)
+}
+
+fn format_sql(sql: String, dialect_name: String) -> Result<String, Error> {
+    let dialect_type = dialect::dialect_from_name(&dialect_name)?;
+    let dialect = polyglot_sql::dialects::Dialect::get(dialect_type);
+
+    let expressions = polyglot_sql::parse(&sql, dialect_type)
+        .map_err(errors::map_polyglot_error)?;
+
+    let mut results = Vec::with_capacity(expressions.len());
+    for expr in &expressions {
+        let formatted = dialect
+            .generate_pretty(expr)
+            .map_err(errors::map_polyglot_error)?;
+        results.push(formatted);
+    }
+
+    Ok(results.join(";\n"))
+}
+
+fn validate(sql: String, dialect_name: String) -> Result<String, Error> {
+    let dialect_type = dialect::dialect_from_name(&dialect_name)?;
+
+    let result = polyglot_sql::validate(&sql, dialect_type);
+
+    serde_json::to_string(&result)
+        .map_err(|e| errors::polyglot_error(format!("JSON serialization error: {e}")))
+}
+
+fn dialects() -> Vec<String> {
+    dialect::dialect_names()
+}
+
+fn version() -> &'static str {
+    env!("CARGO_PKG_VERSION")
+}
+
+#[magnus::init]
+fn init(ruby: &Ruby) -> Result<(), Error> {
+    let module = ruby.define_module("Polyglot")?;
+
+    errors::define_exceptions(ruby, &module)?;
+
+    module.define_singleton_method("_transpile", function!(transpile, 3))?;
+    module.define_singleton_method("_parse", function!(parse, 2))?;
+    module.define_singleton_method("_parse_one", function!(parse_one, 2))?;
+    module.define_singleton_method("_generate", function!(generate, 2))?;
+    module.define_singleton_method("_format", function!(format_sql, 2))?;
+    module.define_singleton_method("_validate", function!(validate, 2))?;
+    module.define_singleton_method("dialects", function!(dialects, 0))?;
+    module.define_singleton_method("native_version", function!(version, 0))?;
+
+    Ok(())
+}

data/lib/polyglot/validation_result.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Polyglot
+  class ValidationResult
+    attr_reader :errors
+
+    def initialize(data)
+      @valid = data["valid"]
+      @errors = (data["errors"] || []).map { |e| ValidationError.new(e) }
+    end
+
+    def valid?
+      @valid
+    end
+
+    def to_h
+      {
+        valid: @valid,
+        errors: @errors.map(&:to_h)
+      }
+    end
+
+    def inspect
+      "#<Polyglot::ValidationResult valid=#{@valid} errors=#{@errors.length}>"
+    end
+  end
+
+  class ValidationError
+    attr_reader :message, :line, :column, :severity, :code
+
+    def initialize(data)
+      @message = data["message"]
+      @line = data["line"]
+      @column = data["column"]
+      @severity = data["severity"]
+      @code = data["code"]
+    end
+
+    def error?
+      @severity == "error"
+    end
+
+    def warning?
+      @severity == "warning"
+    end
+
+    def to_h
+      {
+        message: @message,
+        line: @line,
+        column: @column,
+        severity: @severity,
+        code: @code
+      }
+    end
+
+    def inspect
+      "#<Polyglot::ValidationError #{@severity}: #{@message}>"
+    end
+  end
+end

data/lib/polyglot/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Polyglot
+  VERSION = "0.1.0"
+end

data/lib/polyglot.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require_relative "polyglot/version"
+
+# Load the native extension
+begin
+  RUBY_VERSION =~ /(\d+\.\d+)/
+  require "polyglot/#{Regexp.last_match(1)}/polyglot_rb"
+rescue LoadError
+  require "polyglot/polyglot_rb"
+end
+
+require_relative "polyglot/validation_result"
+require "json"
+
+module Polyglot
+  class << self
+    # Transpile SQL from one dialect to another.
+    #
+    # @param sql [String] the SQL statement(s) to transpile
+    # @param from [String, Symbol] the source dialect
+    # @param to [String, Symbol] the target dialect
+    # @return [Array<String>] the transpiled SQL statements
+    #
+    # @example
+    #   Polyglot.transpile("SELECT NOW()", from: :postgres, to: :mysql)
+    #   # => ["SELECT CURRENT_TIMESTAMP()"]
+    #
+    def transpile(sql, from:, to:)
+      _transpile(sql, from.to_s, to.to_s)
+    end
+
+    # Parse SQL into an abstract syntax tree.
+    #
+    # @param sql [String] the SQL to parse
+    # @param dialect [String, Symbol] the SQL dialect (default: :generic)
+    # @return [Array<Hash>] the parsed AST expressions
+    #
+    # @example
+    #   Polyglot.parse("SELECT 1", dialect: :postgres)
+    #   # => [{"select" => {"expressions" => [...]}}]
+    #
+    def parse(sql, dialect: :generic)
+      JSON.parse(_parse(sql, dialect.to_s))
+    end
+
+    # Parse a single SQL statement into an AST.
+    #
+    # @param sql [String] a single SQL statement
+    # @param dialect [String, Symbol] the SQL dialect (default: :generic)
+    # @return [Hash] the parsed AST expression
+    # @raise [Polyglot::ParseError] if the SQL contains more or fewer than one statement
+    #
+    # @example
+    #   ast = Polyglot.parse_one("SELECT 1", dialect: :postgres)
+    #
+    def parse_one(sql, dialect: :generic)
+      JSON.parse(_parse_one(sql, dialect.to_s))
+    end
+
+    # Generate SQL from an AST expression.
+    #
+    # @param ast [Hash, String] the AST expression (Hash or JSON string)
+    # @param dialect [String, Symbol] the target SQL dialect (default: :generic)
+    # @return [String] the generated SQL
+    #
+    # @example
+    #   ast = Polyglot.parse_one("SELECT 1", dialect: :postgres)
+    #   Polyglot.generate(ast, dialect: :mysql)
+    #
+    def generate(ast, dialect: :generic)
+      json = ast.is_a?(String) ? ast : JSON.generate(ast)
+      _generate(json, dialect.to_s)
+    end
+
+    # Format (pretty-print) SQL.
+    #
+    # @param sql [String] the SQL to format
+    # @param dialect [String, Symbol] the SQL dialect (default: :generic)
+    # @return [String] the formatted SQL
+    #
+    # @example
+    #   Polyglot.format("SELECT a, b FROM t WHERE x = 1", dialect: :postgres)
+    #
+    def format(sql, dialect: :generic)
+      _format(sql, dialect.to_s)
+    end
+
+    # Validate SQL syntax.
+    #
+    # @param sql [String] the SQL to validate
+    # @param dialect [String, Symbol] the SQL dialect (default: :generic)
+    # @return [Polyglot::ValidationResult]
+    #
+    # @example
+    #   result = Polyglot.validate("SELECT 1", dialect: :postgres)
+    #   result.valid? # => true
+    #
+    # @example Invalid SQL
+    #   result = Polyglot.validate("SELEC 1")
+    #   result.valid? # => false
+    #   result.errors.first.message # => "..."
+    #
+    def validate(sql, dialect: :generic)
+      data = JSON.parse(_validate(sql, dialect.to_s))
+      ValidationResult.new(data)
+    end
+  end
+end

metadata

@@ -0,0 +1,111 @@
+--- !ruby/object:Gem::Specification
+name: polyglot-sql
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Polyglot Contributors
+bindir: bin
+cert_chain: []
+date: 1980-01-02 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'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+description: SQL dialect translator supporting 30+ databases — Ruby bindings via Magnus
+email: []
+executables: []
+extensions:
+- ext/polyglot_rb/extconf.rb
+extra_rdoc_files: []
+files:
+- Cargo.toml
+- LICENSE
+- README.md
+- ext/polyglot_rb/Cargo.toml
+- ext/polyglot_rb/extconf.rb
+- ext/polyglot_rb/src/dialect.rs
+- ext/polyglot_rb/src/errors.rs
+- ext/polyglot_rb/src/lib.rs
+- lib/polyglot.rb
+- lib/polyglot/validation_result.rb
+- lib/polyglot/version.rb
+homepage: https://github.com/catkins/polyglot-sql-rb
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/catkins/polyglot-sql-rb
+  source_code_uri: https://github.com/catkins/polyglot-sql-rb
+  changelog_uri: https://github.com/catkins/polyglot-sql-rb/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.4
+specification_version: 4
+summary: Ruby bindings for polyglot-sql
+test_files: []