sqlglot 0.1.0-x86_64-linux-gnu

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: b272b226c1deca727fe3642163d1f5e5aaa25e9dd5055f28880ee41877659641
+  data.tar.gz: 63d25d7d9338a96f64cc86a9b7e2fd41f36703a87c550cd9173d1eae078ee7ac
+SHA512:
+  metadata.gz: 417d2c2a7b4804f0141c65a70717be1aca591fd1e0a6f44f18d04bd582cc6626eecaa2b394b3aa8330e9a602cdc2cb70d7185d5d7948ae13a2875f54a41ba573
+  data.tar.gz: 8411d255c6aa2938cfc57f694b8107e0eb38cea3a80b1d72b31eea0b3b2e97ad1562ffb36b831a042d038f59259d16c75ebc65555c9fac1198aaf4cde9e2932f

data/Gemfile

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+gemspec
+
+group :development, :test do
+  gem "rspec", "~> 3.12"
+  gem "rake", "~> 13.0"
+end

data/Rakefile

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+namespace :cargo do
+  desc "Build the sql-glot-rust shared library"
+  task :build do
+    ext_dir = File.expand_path("ext/sqlglot_rust", __dir__)
+    rust_dir = File.join(ext_dir, "sql-glot-rust")
+
+    unless Dir.exist?(rust_dir)
+      sh "git clone --depth 1 --branch v0.10.0 " \
+         "https://github.com/protegrity/sql-glot-rust.git #{rust_dir}"
+    end
+
+    sh "cargo build --release --manifest-path #{File.join(rust_dir, 'Cargo.toml')}"
+
+    lib_dir = File.expand_path("lib/sqlglot", __dir__)
+    release_dir = File.join(rust_dir, "target", "release")
+
+    so_file = Dir[File.join(release_dir, "libsqlglot_rust.{so,dylib,dll}")].first
+    if so_file
+      cp so_file, lib_dir, verbose: true
+    else
+      abort "ERROR: shared library not found in #{release_dir}"
+    end
+  end
+end
+
+task default: :spec

data/ext/sqlglot_rust/extconf.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+# extconf.rb — invoked by `gem install` or `bundle install` to build the
+# sql-glot-rust shared library from source.
+#
+# Requirements:
+#   - git (to clone the repository)
+#   - cargo / rustc (Rust toolchain, 1.85+)
+
+require "fileutils"
+
+RUST_REPO  = "https://github.com/protegrity/sql-glot-rust.git"
+RUST_TAG   = "v0.10.0"
+EXT_DIR    = __dir__
+RUST_DIR   = File.join(EXT_DIR, "sql-glot-rust")
+LIB_DIR    = File.expand_path("../../lib/sqlglot", EXT_DIR)
+
+# ── Skip build if the shared library already exists ────────────────────
+
+so_already_built = Dir[File.join(LIB_DIR, "libsqlglot_rust.{so,dylib,dll}")].any?
+
+if so_already_built
+  puts "libsqlglot_rust already exists in #{LIB_DIR}, skipping Rust build."
+  File.write(File.join(EXT_DIR, "Makefile"), "all:\ninstall:\nclean:\n")
+  exit 0
+end
+
+# ── Pre-flight checks ─────────────────────────────────────────────────
+
+def command_exists?(cmd)
+  system("command -v #{cmd} > /dev/null 2>&1")
+end
+
+unless command_exists?("cargo")
+  abort <<~MSG
+    ERROR: `cargo` not found on PATH.
+
+    The sqlglot gem requires the Rust toolchain to compile the native library.
+    Install Rust via https://rustup.rs and ensure `cargo` is on your PATH,
+    then run `gem install sqlglot` again.
+  MSG
+end
+
+unless command_exists?("git")
+  abort "ERROR: `git` not found on PATH. It is needed to fetch the Rust source."
+end
+
+# ── Clone the Rust source ─────────────────────────────────────────────
+
+unless Dir.exist?(RUST_DIR)
+  puts "Cloning #{RUST_REPO} at #{RUST_TAG}..."
+  ok = system("git", "clone", "--depth", "1", "--branch", RUST_TAG, RUST_REPO, RUST_DIR)
+  abort "ERROR: git clone failed" unless ok
+end
+
+# ── Build the shared library ──────────────────────────────────────────
+
+puts "Building sql-glot-rust (release)..."
+ok = system("cargo", "build", "--release",
+            "--manifest-path", File.join(RUST_DIR, "Cargo.toml"))
+abort "ERROR: cargo build failed" unless ok
+
+# ── Copy the artifact into lib/sqlglot/ ───────────────────────────────
+
+release_dir = File.join(RUST_DIR, "target", "release")
+
+so_glob = File.join(release_dir, "libsqlglot_rust.{so,dylib,dll}")
+so_file = Dir[so_glob].first
+
+if so_file
+  FileUtils.mkdir_p(LIB_DIR)
+  FileUtils.cp(so_file, LIB_DIR, verbose: true)
+  puts "Installed #{File.basename(so_file)} into #{LIB_DIR}"
+else
+  abort "ERROR: shared library not found in #{release_dir}. " \
+        "Expected libsqlglot_rust.so, .dylib, or .dll"
+end
+
+# ── Write a dummy Makefile (required by rubygems extension protocol) ──
+
+File.write(File.join(EXT_DIR, "Makefile"), <<~MAKEFILE)
+  all:
+  install:
+  clean:
+MAKEFILE

data/lib/sqlglot/ast_walker.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+module Sqlglot
+  # Generic helpers for traversing the JSON AST Hash returned by
+  # {Sqlglot.parse}.
+  #
+  # The AST is a nested structure of Hashes and Arrays.  Statement and
+  # expression types appear as single-key Hashes:
+  #
+  #   {"Column" => {"name" => "id", "table" => "users", ...}}
+  #   {"Number" => "42"}
+  #   {"BinaryOp" => {"left" => ..., "op" => "Eq", "right" => ...}}
+  #
+  # @api private
+  module AstWalker
+    module_function
+
+    # Depth-first walk of the AST.  Yields every Hash node whose single
+    # key is a recognised AST type name (capitalised, e.g. "Column").
+    #
+    # @param node [Hash, Array, Object] the AST subtree
+    # @yieldparam type_key [String] the AST type name
+    # @yieldparam value [Object] the contents of that node
+    # @yieldparam node [Hash] the full single-key Hash
+    def walk(node, &block)
+      case node
+      when Hash
+        node.each do |key, value|
+          # Yield if this looks like a typed AST node (capitalised key).
+          if key.is_a?(String) && key =~ /\A[A-Z]/
+            yield(key, value, node)
+          end
+          walk(value, &block)
+        end
+      when Array
+        node.each { |child| walk(child, &block) }
+      end
+    end
+
+    # Collect all nodes of a given AST type anywhere in the subtree.
+    #
+    # @param node [Hash, Array] the AST subtree
+    # @param type_key [String] e.g. "Column", "Table", "Function"
+    # @return [Array<Object>] the value side of each matching node
+    def find_all(node, type_key)
+      results = []
+      walk(node) do |key, value, _|
+        results << value if key == type_key
+      end
+      results
+    end
+
+    # Collect all Column references within an expression subtree.
+    # Returns an array of +{name:, table:}+ hashes.
+    #
+    # @param node [Hash, Array]
+    # @return [Array<Hash>]
+    def extract_columns(node)
+      find_all(node, "Column").map do |col|
+        { name: col["name"], table: col["table"] }
+      end
+    end
+
+    # Convert an AST literal node to a Ruby value.
+    #
+    #   {"Number" => "42"}         => 42
+    #   {"Number" => "3.14"}       => 3.14
+    #   {"StringLiteral" => "foo"} => "foo"
+    #   {"Boolean" => true}        => true
+    #   {"Null" => ...}            => nil
+    #
+    # @param node [Hash]
+    # @return [Integer, Float, String, true, false, nil]
+    def extract_value(node)
+      return nil unless node.is_a?(Hash)
+
+      if node.key?("Number")
+        num = node["Number"]
+        num.include?(".") ? num.to_f : num.to_i
+      elsif node.key?("StringLiteral")
+        node["StringLiteral"]
+      elsif node.key?("Boolean")
+        node["Boolean"]
+      elsif node.key?("Null")
+        nil
+      else
+        # Unknown literal type -- return the raw node.
+        node
+      end
+    end
+
+    # Return the single AST type key of a node, if it has exactly one
+    # capitalised key (the standard pattern).
+    #
+    # @param node [Hash]
+    # @return [String, nil]
+    def node_type(node)
+      return nil unless node.is_a?(Hash)
+
+      node.each_key do |k|
+        return k if k.is_a?(String) && k =~ /\A[A-Z]/
+      end
+      nil
+    end
+
+    # Unwrap nested single-key wrappers to get the inner payload.
+    #
+    # For example:
+    #   {"Expr" => {"expr" => {"Column" => {...}}, "alias" => nil}}
+    #
+    # @param node [Hash]
+    # @return [Hash]
+    def unwrap(node)
+      return node unless node.is_a?(Hash) && node.size == 1
+
+      key = node.keys.first
+      val = node.values.first
+      val.is_a?(Hash) ? val : node
+    end
+  end
+end

data/lib/sqlglot/dialect.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Sqlglot
+  # Constants for all 30 SQL dialects supported by sql-glot-rust.
+  #
+  # Each constant holds the string name passed to the Rust FFI.
+  # Use symbols or strings interchangeably in the public API --
+  # {Dialect.resolve} normalizes them.
+  #
+  # @example
+  #   Sqlglot.transpile(sql, from: Sqlglot::Dialect::POSTGRES, to: Sqlglot::Dialect::BIGQUERY)
+  #   Sqlglot.transpile(sql, from: :postgres, to: :bigquery)  # same thing
+  module Dialect
+    # ── Official dialects ──────────────────────────────────────
+    ANSI       = "ansi"
+    ATHENA     = "athena"
+    BIGQUERY   = "bigquery"
+    CLICKHOUSE = "clickhouse"
+    DATABRICKS = "databricks"
+    DUCKDB     = "duckdb"
+    HIVE       = "hive"
+    MYSQL      = "mysql"
+    ORACLE     = "oracle"
+    POSTGRES   = "postgres"
+    PRESTO     = "presto"
+    REDSHIFT   = "redshift"
+    SNOWFLAKE  = "snowflake"
+    SPARK      = "spark"
+    SQLITE     = "sqlite"
+    STARROCKS  = "starrocks"
+    TRINO      = "trino"
+    TSQL       = "tsql"
+
+    # ── Community dialects ─────────────────────────────────────
+    DORIS       = "doris"
+    DREMIO      = "dremio"
+    DRILL       = "drill"
+    DRUID       = "druid"
+    EXASOL      = "exasol"
+    FABRIC      = "fabric"
+    MATERIALIZE = "materialize"
+    PRQL        = "prql"
+    RISINGWAVE  = "risingwave"
+    SINGLESTORE = "singlestore"
+    TABLEAU     = "tableau"
+    TERADATA    = "teradata"
+
+    # Common aliases accepted by the Rust library's Dialect::from_str.
+    ALIASES = {
+      "postgresql" => POSTGRES,
+      "mssql"      => TSQL,
+      "sqlserver"  => TSQL,
+      "mariadb"    => MYSQL,
+    }.freeze
+
+    # All known dialect names (constants + aliases).
+    ALL = constants
+      .reject { |c| %i[ALIASES ALL].include?(c) }
+      .map { |c| const_get(c) }
+      .freeze
+
+    # Normalize a dialect argument to the string the Rust FFI expects.
+    #
+    # Accepts symbols, strings, or nil. Unknown values raise ArgumentError.
+    #
+    # @param name [Symbol, String, nil]
+    # @return [String, nil] the dialect string, or nil if name is nil
+    def self.resolve(name)
+      return nil if name.nil?
+
+      key = name.to_s.downcase.strip
+      return key if ALL.include?(key)
+      return ALIASES[key] if ALIASES.key?(key)
+
+      raise ArgumentError, "Unknown dialect: #{name.inspect}. " \
+                           "Known dialects: #{ALL.sort.join(', ')}"
+    end
+  end
+end

data/lib/sqlglot/error.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Sqlglot
+  # Base error for all Sqlglot errors.
+  class Error < StandardError; end
+
+  # Raised when the shared library cannot be found or loaded.
+  class LibraryNotFoundError < Error; end
+
+  # Raised when SQL parsing fails (the Rust FFI returned NULL).
+  class ParseError < Error; end
+
+  # Raised when SQL transpilation fails.
+  class TranspileError < Error; end
+
+  # Raised when SQL generation from an AST fails.
+  class GenerateError < Error; end
+end

data/lib/sqlglot/native.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+require "ffi"
+require "json"
+
+module Sqlglot
+  # Low-level FFI bindings to libsqlglot_rust.
+  #
+  # This module is not intended for direct use -- see the public API on
+  # {Sqlglot} instead.  All returned C strings are freed via +sqlglot_free+
+  # in +ensure+ blocks so callers never need to manage memory.
+  #
+  # @api private
+  module Native
+    extend FFI::Library
+
+    # Locate the shared library.  Search order:
+    #   1. SQLGLOT_LIB_PATH environment variable (explicit override)
+    #   2. lib/sqlglot/ inside the gem (where extconf.rb copies the build)
+    #   3. ext/sqlglot_rust/sql-glot-rust/target/release/ (dev builds)
+    #   4. System library path (LD_LIBRARY_PATH / DYLD_LIBRARY_PATH)
+    LIB_NAME = "sqlglot_rust"
+
+    SOEXT = FFI::Platform::LIBSUFFIX # "so" on Linux, "dylib" on macOS
+
+    def self.find_library
+      # 1. Explicit override
+      if (env_path = ENV["SQLGLOT_LIB_PATH"])
+        return env_path if File.exist?(env_path)
+      end
+
+      gem_root = File.expand_path("../..", __dir__)
+
+      candidates = [
+        # 2. Installed location (lib/sqlglot/)
+        File.join(gem_root, "lib", "sqlglot", "lib#{LIB_NAME}.#{SOEXT}"),
+        # 3. Dev build location
+        File.join(gem_root, "ext", "sqlglot_rust", "sql-glot-rust",
+                  "target", "release", "lib#{LIB_NAME}.#{SOEXT}"),
+      ]
+
+      candidates.each { |path| return path if File.exist?(path) }
+
+      # 4. System path fallback (FFI will search LD_LIBRARY_PATH etc.)
+      LIB_NAME
+    end
+
+    begin
+      ffi_lib find_library
+    rescue LoadError => e
+      raise Sqlglot::LibraryNotFoundError,
+            "Could not load libsqlglot_rust. #{e.message}\n\n" \
+            "Make sure the Rust library is built. Run:\n" \
+            "  rake cargo:build\n\n" \
+            "Or set SQLGLOT_LIB_PATH to the full path of the .so/.dylib file."
+    end
+
+    # ── C function declarations ────────────────────────────────────────
+
+    # char *sqlglot_parse(const char *sql, const char *dialect);
+    attach_function :sqlglot_parse, [:string, :string], :pointer
+
+    # char *sqlglot_transpile(const char *sql, const char *from, const char *to);
+    attach_function :sqlglot_transpile, [:string, :string, :string], :pointer
+
+    # char *sqlglot_generate(const char *ast_json, const char *dialect);
+    attach_function :sqlglot_generate, [:string, :string], :pointer
+
+    # const char *sqlglot_version(void);
+    attach_function :sqlglot_version, [], :string
+
+    # void sqlglot_free(char *ptr);
+    attach_function :sqlglot_free, [:pointer], :void
+
+    # ── Safe wrappers ──────────────────────────────────────────────────
+
+    # Read a C string returned by the FFI, free it, and return a Ruby String.
+    # Raises the given error class if the pointer is NULL.
+    #
+    # @param ptr [FFI::Pointer]
+    # @param error_class [Class<Sqlglot::Error>]
+    # @param message [String]
+    # @return [String]
+    def self.read_and_free(ptr, error_class:, message:)
+      if ptr.null?
+        raise error_class, message
+      end
+
+      ptr.read_string.force_encoding("UTF-8")
+    ensure
+      sqlglot_free(ptr) if ptr && !ptr.null?
+    end
+
+    # Parse SQL and return the JSON AST string.
+    #
+    # @param sql [String]
+    # @param dialect [String, nil]
+    # @return [String] JSON string
+    def self.parse(sql, dialect)
+      ptr = sqlglot_parse(sql, dialect)
+      read_and_free(ptr,
+                    error_class: ParseError,
+                    message: "Failed to parse SQL: #{sql.inspect}")
+    end
+
+    # Transpile SQL from one dialect to another.
+    #
+    # @param sql [String]
+    # @param from_dialect [String, nil]
+    # @param to_dialect [String, nil]
+    # @return [String] transpiled SQL
+    def self.transpile(sql, from_dialect, to_dialect)
+      ptr = sqlglot_transpile(sql, from_dialect, to_dialect)
+      read_and_free(ptr,
+                    error_class: TranspileError,
+                    message: "Failed to transpile SQL: #{sql.inspect}")
+    end
+
+    # Generate SQL from a JSON AST string.
+    #
+    # @param ast_json [String]
+    # @param dialect [String, nil]
+    # @return [String] generated SQL
+    def self.generate(ast_json, dialect)
+      ptr = sqlglot_generate(ast_json, dialect)
+      read_and_free(ptr,
+                    error_class: GenerateError,
+                    message: "Failed to generate SQL from AST")
+    end
+
+    # Return the library version string.
+    #
+    # @return [String]
+    def self.version
+      sqlglot_version()
+    end
+  end
+end