forest_admin_datasource_snowflake 1.29.1

data/lib/forest_admin_datasource_snowflake/utils/query.rb

@@ -0,0 +1,181 @@
+module ForestAdminDatasourceSnowflake
+  module Utils
+    class Query
+      Operators           = ForestAdminDatasourceToolkit::Components::Query::ConditionTree::Operators
+      ConditionTreeBranch = ForestAdminDatasourceToolkit::Components::Query::ConditionTree::Nodes::ConditionTreeBranch
+      ConditionTreeLeaf   = ForestAdminDatasourceToolkit::Components::Query::ConditionTree::Nodes::ConditionTreeLeaf
+
+      def initialize(collection, projection: nil, filter: nil, aggregation: nil, limit: nil)
+        @collection  = collection
+        @projection  = projection
+        @filter      = filter
+        @aggregation = aggregation
+        @limit       = limit
+        @binds       = []
+      end
+
+      def to_sql
+        @binds = []
+        cols = @projection&.columns&.map { |c| q(c) }
+        cols = ['*'] if cols.nil? || cols.empty?
+        sql  = "SELECT #{cols.join(", ")} FROM #{q(@collection.table_name)}"
+
+        where = build_where_clause(@filter&.condition_tree)
+        sql << " WHERE #{where}" if where
+
+        order_by = build_order_by(@filter&.sort)
+        sql << " ORDER BY #{order_by}" if order_by
+
+        if @filter&.page
+          limit  = @filter.page.respond_to?(:limit)  ? @filter.page.limit  : nil
+          offset = @filter.page.respond_to?(:offset) ? @filter.page.offset : nil
+          sql << " LIMIT #{Integer(limit)}" if limit
+          sql << " OFFSET #{Integer(offset)}" if offset
+        end
+
+        [sql, @binds]
+      end
+
+      def to_aggregate_sql
+        @binds = []
+        op_expr = build_aggregation_expression(@aggregation)
+
+        group_cols = (@aggregation.groups || []).map { |g| g[:field] }
+        select_cols = [op_expr, *group_cols.map { |c| q(c) }]
+        sql = "SELECT #{select_cols.join(", ")} FROM #{q(@collection.table_name)}"
+
+        where = build_where_clause(@filter&.condition_tree)
+        sql << " WHERE #{where}" if where
+
+        sql << " GROUP BY #{group_cols.map { |c| q(c) }.join(", ")}" if group_cols.any?
+        sql << " LIMIT #{Integer(@limit)}" if @limit
+
+        [sql, @binds, group_cols]
+      end
+
+      private
+
+      def q(identifier)
+        Identifier.quote(identifier)
+      end
+
+      def build_aggregation_expression(aggregation)
+        op    = aggregation.operation.to_s.upcase
+        field = aggregation.field
+
+        blank_field = field.nil? || field.to_s.empty?
+
+        case op
+        when 'COUNT'
+          blank_field ? 'COUNT(*)' : "COUNT(#{q(field)})"
+        when 'SUM', 'AVG', 'MIN', 'MAX'
+          raise ForestAdminDatasourceSnowflake::Error, "Aggregation '#{op}' requires a field" if blank_field
+
+          "#{op}(#{q(field)})"
+        else
+          raise ForestAdminDatasourceSnowflake::Error, "Unsupported aggregation operation: #{op}"
+        end
+      end
+
+      def build_order_by(sort)
+        return nil if sort.nil? || sort.empty?
+
+        sort.map { |s| "#{q(s[:field])} #{s[:ascending] ? "ASC" : "DESC"}" }.join(', ')
+      end
+
+      def build_where_clause(node)
+        return nil if node.nil?
+
+        case node
+        when ConditionTreeBranch
+          fragments = node.conditions.filter_map { |child| build_where_clause(child) }
+          return nil if fragments.empty?
+
+          joiner = node.aggregator.to_s.upcase == 'OR' ? ' OR ' : ' AND '
+          "(#{fragments.join(joiner)})"
+        when ConditionTreeLeaf
+          translate_leaf(node)
+        else
+          raise ForestAdminDatasourceSnowflake::Error, "Unsupported condition tree node: #{node.class}"
+        end
+      end
+
+      def translate_leaf(leaf)
+        field = q(leaf.field)
+        case leaf.operator
+        when Operators::EQUAL                  then translate_equality(field, leaf.value)
+        when Operators::NOT_EQUAL              then translate_equality(field, leaf.value, negate: true)
+        when Operators::LESS_THAN              then bind!(leaf.value)
+                                                    "#{field} < ?"
+        when Operators::GREATER_THAN           then bind!(leaf.value)
+                                                    "#{field} > ?"
+        when Operators::LESS_THAN_OR_EQUAL     then bind!(leaf.value)
+                                                    "#{field} <= ?"
+        when Operators::GREATER_THAN_OR_EQUAL  then bind!(leaf.value)
+                                                    "#{field} >= ?"
+        when Operators::IN                     then translate_in(field, leaf.value)
+        when Operators::NOT_IN                 then translate_in(field, leaf.value, negate: true)
+        when Operators::PRESENT                then "#{field} IS NOT NULL"
+        when Operators::MISSING                then "#{field} IS NULL"
+        when Operators::BLANK                  then "(#{field} IS NULL OR #{field} = '')"
+        when Operators::CONTAINS               then translate_like(field, "%#{leaf.value}%")
+        when Operators::I_CONTAINS             then translate_ilike(field, "%#{leaf.value}%")
+        when Operators::NOT_CONTAINS           then translate_like(field, "%#{leaf.value}%", negate: true)
+        when Operators::NOT_I_CONTAINS         then translate_ilike(field, "%#{leaf.value}%", negate: true)
+        when Operators::STARTS_WITH            then translate_like(field, "#{leaf.value}%")
+        when Operators::I_STARTS_WITH          then translate_ilike(field, "#{leaf.value}%")
+        when Operators::ENDS_WITH              then translate_like(field, "%#{leaf.value}")
+        when Operators::I_ENDS_WITH            then translate_ilike(field, "%#{leaf.value}")
+        when Operators::LIKE                   then translate_like(field, leaf.value)
+        when Operators::I_LIKE                 then translate_ilike(field, leaf.value)
+        when Operators::SHORTER_THAN           then bind!(leaf.value)
+                                                    "LENGTH(#{field}) < ?"
+        when Operators::LONGER_THAN            then bind!(leaf.value)
+                                                    "LENGTH(#{field}) > ?"
+        else
+          raise ForestAdminDatasourceSnowflake::Error,
+                "Unsupported operator '#{leaf.operator}' on field '#{leaf.field}'"
+        end
+      end
+
+      def translate_equality(quoted_field, value, negate: false)
+        return "#{quoted_field} #{negate ? "IS NOT NULL" : "IS NULL"}" if value.nil?
+
+        bind!(value)
+        "#{quoted_field} #{negate ? "<>" : "="} ?"
+      end
+
+      def translate_in(quoted_field, values, negate: false)
+        list = Array(values)
+        return negate ? '1=1' : '1=0' if list.empty?
+
+        non_nils = list.compact
+        null_term = "#{quoted_field} #{negate ? "IS NOT NULL" : "IS NULL"}"
+        return null_term if non_nils.empty?
+
+        placeholders = non_nils.map do |v|
+          bind!(v)
+          '?'
+        end.join(', ')
+        in_term = "#{quoted_field} #{negate ? "NOT IN" : "IN"} (#{placeholders})"
+        return in_term if non_nils.size == list.size
+
+        "(#{null_term}#{negate ? " AND " : " OR "}#{in_term})"
+      end
+
+      def translate_like(quoted_field, value, negate: false)
+        bind!(value)
+        "#{quoted_field} #{negate ? "NOT LIKE" : "LIKE"} ?"
+      end
+
+      def translate_ilike(quoted_field, value, negate: false)
+        bind!(value)
+        "LOWER(#{quoted_field}) #{negate ? "NOT LIKE" : "LIKE"} LOWER(?)"
+      end
+
+      def bind!(value)
+        @binds << value
+      end
+    end
+  end
+end

data/lib/forest_admin_datasource_snowflake/version.rb

@@ -0,0 +1,3 @@
+module ForestAdminDatasourceSnowflake
+  VERSION = "1.29.1"
+end

data/lib/forest_admin_datasource_snowflake.rb

@@ -0,0 +1,9 @@
+require_relative 'forest_admin_datasource_snowflake/version'
+require 'odbc'
+require 'zeitwerk'
+
+Zeitwerk::Loader.for_gem.setup
+
+module ForestAdminDatasourceSnowflake
+  class Error < StandardError; end
+end

metadata

@@ -0,0 +1,103 @@
+--- !ruby/object:Gem::Specification
+name: forest_admin_datasource_snowflake
+version: !ruby/object:Gem::Version
+  version: 1.29.1
+platform: ruby
+authors:
+- Forest Admin
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2026-05-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: connection_pool
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.4'
+- !ruby/object:Gem::Dependency
+  name: ruby-odbc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.99999'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.99999'
+- !ruby/object:Gem::Dependency
+  name: zeitwerk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.3'
+description: Exposes Snowflake tables and views as Forest Admin collections via ODBC.
+  Queries are translated from Forest ConditionTrees to parameterized SQL; no ActiveRecord
+  involvement on the Snowflake side.
+email:
+- support@forestadmin.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- LICENSE
+- Rakefile
+- forest_admin_datasource_snowflake.gemspec
+- lib/forest_admin_datasource_snowflake.rb
+- lib/forest_admin_datasource_snowflake/collection.rb
+- lib/forest_admin_datasource_snowflake/datasource.rb
+- lib/forest_admin_datasource_snowflake/parser/column.rb
+- lib/forest_admin_datasource_snowflake/parser/relation.rb
+- lib/forest_admin_datasource_snowflake/utils/identifier.rb
+- lib/forest_admin_datasource_snowflake/utils/query.rb
+- lib/forest_admin_datasource_snowflake/version.rb
+homepage: https://www.forestadmin.com
+licenses:
+- GPL-3.0
+metadata:
+  homepage_uri: https://www.forestadmin.com
+  source_code_uri: https://github.com/ForestAdmin/agent-ruby
+  changelog_uri: https://github.com/ForestAdmin/agent-ruby/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'false'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.20
+signing_key:
+specification_version: 4
+summary: Snowflake datasource for Forest Admin (read-only).
+test_files: []