manifold-cli 0.0.17 → 0.0.18

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 61582d1f6df6c8a674f9ef9b2374ae231fc98da47435ea5893d5077cb4dad34e
-  data.tar.gz: ab91d3938b7a382ac003a467cd04d19cc6059804fe21e099e7e2aa60675eed3a
+  metadata.gz: 26f9112132a14f5bbb3cd123dc4d399ed9d618ec41638eaf43b5bbb0f870b6dd
+  data.tar.gz: cc8bc857ca5163f2e86ffe8656fe48b8fb46c3295bfa7f3ffad531597e0b15df
 SHA512:
-  metadata.gz: 5cc06d2a611b1b29edbb466ab20cf8b82d4b99d609f57b71bd5e7f6098e7fcbd636c46a662306b8318c429148fbba3b4b6d6ddc3c603cddcb53ff81c9fe50f4c
-  data.tar.gz: b8e44688d8e47628dc718bf992eb28114fde80a7cd60975e7a49cf91ce05fdf3ed2b6bc349c73332801ed5934b0a56a6f71ca100ad4b02df763c2f67cd2a3f8b
+  metadata.gz: dba055e83e3ef141fd49c8af5d7079d33a81ac6a54539c32270e86ecbd73840ee183f611e99f7c985c1b7c5cbb7bd32b2ac650abc8faa85946600a2ddf10af1b
+  data.tar.gz: d44010ad67f25f6ee9bd4762ee34a319062ebb82d68af81192bdba8becebad6850fd65e3e5e12f628114dd19ba17378bbecf196320e226613bb29e4062b3a80d

data/lib/manifold/api/workspace.rb

@@ -172,11 +172,7 @@ module Manifold
         return unless manifold_file
 
         sql_builder = Terraform::SQLBuilder.new(name, manifold_yaml)
-        metrics_builder = Terraform::MetricsBuilder.new(manifold_yaml)
-        sql = sql_builder.build_manifold_merge_sql(metrics_builder) do
-          metrics_builder.build_metrics_struct
-        end
-
+        sql = sql_builder.build_manifold_merge_sql
         routines_directory.join("merge_manifold.sql").write(sql)
       end
 

data/lib/manifold/templates/workspace_template.yml

@@ -24,19 +24,5 @@ metrics:
         sequenceSum:
           field: context.sequence
 
-    source: my_project.my_dataset.my_table
-    filter: timestamp >= TIMESTAMP_SUB(CURRENT_TIMESTAMP(), INTERVAL 90 DAY)
-
-  taps:
-    breakouts:
-      paid: IS_PAID(context.location)
-      organic: IS_ORGANIC(context.location)
-
-    aggregations:
-      countif: tapCount
-      sumif:
-        sequenceSum:
-          field: context.sequence
-
-    source: my_project.my_dataset.my_table
+    source: my_project.render_metrics
     filter: timestamp >= TIMESTAMP_SUB(CURRENT_TIMESTAMP(), INTERVAL 90 DAY)

data/lib/manifold/terraform/workspace_configuration.rb

@@ -3,110 +3,40 @@
 module Manifold
   module Terraform
     # Handles building metrics SQL for manifold routines
-    class MetricsBuilder
-      def initialize(manifold_config)
+    class MetricsSQLBuilder
+      def initialize(name, manifold_config)
+        @name = name
         @manifold_config = manifold_config
       end
 
-      def build_metrics_struct
-        return "" unless @manifold_config["metrics"]
-
-        metric_groups = @manifold_config["metrics"].map do |group_name, group_config|
-          build_group_struct(group_name, group_config)
-        end
-
-        metric_groups.join(",\n")
+      def build_metrics_select
+        <<~SQL
+          SELECT
+              id,
+              timestamp,
+              #{build_metrics_struct}
+            FROM #{build_metric_joins}
+        SQL
       end
 
       private
 
-      def build_group_struct(group_name, group_config)
-        return "" unless valid_group_config?(group_config)
-
-        breakout_structs = build_breakout_structs(group_config)
-        return "" if breakout_structs.empty?
-
-        "\tSTRUCT(\n#{breakout_structs.join(",\n")}\n\t) AS #{group_name}"
-      end
-
-      def valid_group_config?(group_config)
-        group_config["breakouts"] &&
-          group_config["aggregations"] &&
-          !group_config["breakouts"].empty? &&
-          !group_config["aggregations"].empty?
-      end
-
-      def build_breakout_structs(group_config)
-        group_config["breakouts"].map do |name, config|
-          build_breakout_struct(name, config, group_config)
-        end.compact
-      end
-
-      def build_breakout_struct(name, config, group_config)
-        condition = build_breakout_condition(name, config, group_config)
-        metrics = build_breakout_metrics(group_config, condition)
-        return if metrics.empty?
-
-        "\t\tSTRUCT(\n\t\t\t#{metrics}\n\t\t) AS #{name}"
-      end
-
-      def build_breakout_metrics(group_config, condition)
-        metrics = []
-        add_count_metrics(metrics, group_config, condition)
-        add_sum_metrics(metrics, group_config, condition)
-        metrics.join(",\n\t\t\t")
-      end
-
-      def add_count_metrics(metrics, group_config, condition)
-        return unless group_config.dig("aggregations", "countif")
-
-        metrics << "COUNTIF(#{condition}) AS #{group_config["aggregations"]["countif"]}"
-      end
-
-      def add_sum_metrics(metrics, group_config, condition)
-        group_config.dig("aggregations", "sumif")&.each do |name, config|
-          metrics << "SUM(IF(#{condition}, #{config["field"]}, 0)) AS #{name}"
-        end
-      end
-
-      def build_breakout_condition(_name, config, group_config)
-        return config unless config.is_a?(Hash)
-
-        operator = config["operator"]
-        fields = config["fields"]
-        build_operator_condition(operator, fields, group_config)
-      end
-
-      def build_operator_condition(operator, fields, group_config)
-        conditions = fields.map { |f| group_config["breakouts"][f] }
-        case operator
-        when "AND", "OR" then join_conditions(conditions, operator)
-        when "NOT" then negate_condition(conditions.first)
-        when "NAND", "NOR" then negate_joined_conditions(conditions, operator[1..])
-        when "XOR" then build_xor_condition(conditions)
-        when "XNOR" then build_xnor_condition(conditions)
-        else config
-        end
-      end
-
-      def join_conditions(conditions, operator)
-        conditions.join(" #{operator} ")
-      end
-
-      def negate_condition(condition)
-        "NOT (#{condition})"
+      def build_metrics_struct
+        metric_groups = @manifold_config["metrics"].keys
+        metric_groups.map { |group| "#{group}.metrics #{group}" }.join(",\n    ")
       end
 
-      def negate_joined_conditions(conditions, operator)
-        "NOT (#{join_conditions(conditions, operator)})"
-      end
+      def build_metric_joins
+        metric_groups = @manifold_config["metrics"]
+        joins = metric_groups.map { |group, config| "#{config["source"]} AS #{group}" }
+        first = joins.shift
+        return first if joins.empty?
 
-      def build_xor_condition(conditions)
-        "(#{conditions[0]} AND NOT #{conditions[1]}) OR (NOT #{conditions[0]} AND #{conditions[1]})"
+        "#{first}\n  #{joins.map { |table| "FULL OUTER JOIN #{table} USING (id, timestamp)" }.join("\n  ")}"
       end
 
-      def build_xnor_condition(conditions)
-        "(#{conditions[0]} AND #{conditions[1]}) OR (NOT #{conditions[0]} AND NOT #{conditions[1]})"
+      def timestamp_field
+        @manifold_config&.dig("timestamp", "field")
       end
     end
 
@@ -115,17 +45,17 @@ module Manifold
       def initialize(name, manifold_config)
         @name = name
         @manifold_config = manifold_config
+        @metrics_builder = MetricsSQLBuilder.new(name, manifold_config)
       end
 
-      def build_manifold_merge_sql(_metrics_builder, &)
+      def build_manifold_merge_sql
         return "" unless valid_config?
 
         <<~SQL
           MERGE #{@name}.Manifold AS target USING (
-            #{build_metrics_cte(&)}
-            #{build_final_select}
+            #{build_source_query}
           ) AS source
-          ON source.id = target.id AND source.timestamp = target.timestamp
+          #{build_merge_conditions}
           #{build_merge_actions}
         SQL
       end
@@ -153,55 +83,30 @@ module Manifold
         first_group&.dig("source")
       end
 
-      def interval
-        @manifold_config&.dig("timestamp", "interval") || "DAY"
-      end
-
-      def where_clause
-        first_group = @manifold_config["metrics"]&.values&.first
-        return "" unless first_group&.dig("filter")
-
-        "WHERE #{first_group["filter"]}"
-      end
-
       def timestamp_field
         @manifold_config&.dig("timestamp", "field")
       end
 
-      def build_metrics_cte(&)
+      def build_source_query
         <<~SQL
           WITH Metrics AS (
-            #{build_metrics_select(&)}
+            #{@metrics_builder.build_metrics_select}
           )
-        SQL
-      end
 
-      def build_metrics_select(&block)
-        <<~SQL
-          SELECT
-            id,
-            TIMESTAMP_TRUNC(#{timestamp_field}, #{interval}) timestamp,
-            STRUCT(
-              #{block.call}
-            ) AS metrics
-          FROM #{source_table}
-          #{where_clause}
-          GROUP BY 1, 2
-        SQL
-      end
-
-      def build_final_select
-        <<~SQL
           SELECT
             id,
             timestamp,
             Dimensions.dimensions,
-            Metrics.metrics
+            (SELECT AS STRUCT Metrics.* EXCEPT(id, timestamp)) metrics
           FROM Metrics
-          LEFT JOIN #{@name}.Dimensions USING (id)
+          JOIN #{@name}.Dimensions USING (id)
         SQL
       end
 
+      def build_merge_conditions
+        "ON source.id = target.id AND source.timestamp = target.timestamp"
+      end
+
       def build_merge_actions
         <<~SQL
           WHEN MATCHED THEN
@@ -298,8 +203,8 @@ module Manifold
 
       def routine_config
         routines = {
-          "merge_dimensions" => dimensions_routine_attributes
-          # "merge_manifold" => manifold_routine_attributes
+          "merge_dimensions" => dimensions_routine_attributes,
+          "merge_manifold" => manifold_routine_attributes
         }.compact
 
         routines.empty? ? nil : routines

data/lib/manifold/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Manifold
-  VERSION = "0.0.17"
+  VERSION = "0.0.18"
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: manifold-cli
 version: !ruby/object:Gem::Version
-  version: 0.0.17
+  version: 0.0.18
 platform: ruby
 authors:
 - claytongentry
 bindir: bin
 cert_chain: []
-date: 2025-02-18 00:00:00.000000000 Z
+date: 2025-02-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thor