dwh 0.1.1 → 0.3.0

data/lib/dwh/adapters/my_sql.rb

@@ -219,7 +219,13 @@ module DWH
         super
         require 'mysql2'
       rescue LoadError
-        raise ConfigError, "Required 'MySql2' gem missing. Please add it to your Gemfile."
+        raise ConfigError, <<~MSG
+          MySQL adapter requires the 'mysql2' gem.
+
+          Install with: gem install mysql2
+
+          System libraries: https://dev.mysql.com/downloads/
+        MSG
       end
 
       def result_to_csv(result)

data/lib/dwh/adapters/postgres.rb

@@ -27,7 +27,7 @@ module DWH
       config :schema, String, default: 'public', message: 'schema name. defaults to "public"'
       config :username, String, required: true, message: 'connection username'
       config :password, String, required: false, default: nil, message: 'connection password'
-      config :query_timeout, String, required: false, default: 3600, message: 'query execution timeout in seconds'
+      config :query_timeout, Integer, required: false, default: 3600, message: 'query execution timeout in seconds'
       config :ssl, Boolean, required: false, default: false, message: 'use ssl'
       config :client_name, String, required: false, default: 'DWH Ruby Gem', message: 'The name of the connecting app'
 
@@ -45,7 +45,7 @@ module DWH
           password: config[:password],
           application_name: config[:client_name]
         }.merge(extra_connection_params)
-        properties[:options] = "#{properties[:options]} -c statement_timeout=#{config[:query_timeout]}s"
+        properties[:options] = "#{properties[:options]} -c statement_timeout=#{config[:query_timeout] * 1000}"
 
         @connection = PG.connect(properties)
 
@@ -114,7 +114,7 @@ module DWH
         db_table = Table.new table, schema: qualifiers[:schema]
 
         schema_where = ''
-        if db_table.schema.present?
+        if db_table.schema?
           schema_where = "AND table_schema = '#{db_table.schema}'"
         elsif schema?
           schema_where = "AND table_schema in (#{qualified_schema_name})"
@@ -143,7 +143,7 @@ module DWH
 
       # True if the configuration was setup with a schema.
       def schema?
-        config[:schema].present?
+        !config[:schema].nil? && !config[:schema]&.strip&.empty?
       end
 
       # (see Adapter#execute)
@@ -221,7 +221,13 @@ module DWH
         super
         require 'pg'
       rescue LoadError
-        raise ConfigError, "Required 'pg' gem missing. Please add it to your Gemfile."
+        raise ConfigError, <<~MSG
+          PostgreSQL adapter requires the 'pg' gem.
+
+          Install with: gem install pg
+
+          System libraries: https://www.postgresql.org/download/
+        MSG
       end
 
       private

data/lib/dwh/adapters/redshift.rb

@@ -0,0 +1,48 @@
+module DWH
+  module Adapters
+    # Redshift adapter. Please ensure the pg gem is available before using this adapter.
+    # Generally, adapters should be created using {DWH::Factory#create DWH.create}. Where a configuration
+    # is passed in as options hash or argument list.
+    #
+    # @example Basic connection with required only options
+    #   DWH.create(:redshift, {host: 'localhost', database: 'redshift',
+    #     username: 'redshift'})
+    #
+    # @example Connection with cert based SSL connection
+    #   DWH.create(:redshift, {host: 'localhost', database: 'redshift',
+    #     username: 'redshift', ssl: true,
+    #     extra_connection_params: { sslmode: 'require' })
+    #
+    #   valid sslmodes: disable, prefer, require, verify-ca, verify-full
+    #   For modes requiring Certs make sure you add the appropirate params
+    #   to extra_connection_params. (ie sslrootcert, sslcert etc.)
+    #
+    # @example Connection sending custom application name
+    #   DWH.create(:redshift, {host: 'localhost', database: 'redshift',
+    #     username: 'redshift', application_name: "Strata CLI" })
+    class Redshift < Postgres
+      config :host, String, required: true, message: 'server host ip address or domain name'
+      config :port, Integer, required: false, default: 5439, message: 'port to connect to'
+      config :database, String, required: true, message: 'name of database to connect to'
+      config :schema, String, default: 'public', message: 'schema name. defaults to "public"'
+      config :username, String, required: true, message: 'connection username'
+      config :password, String, required: false, default: nil, message: 'connection password'
+      config :query_timeout, Integer, required: false, default: 3600, message: 'query execution timeout in seconds'
+      config :client_name, String, required: false, default: 'DWH Ruby Gem', message: 'The name of the connecting app'
+      config :ssl, Boolean, required: false, default: false, message: 'use ssl'
+
+      # Need to override default add method
+      # since redshift doesn't support quarter as an
+      # interval.
+      # @param unit [String] Should be one of day, month, quarter etc
+      # @param val [String, Integer] The number of days to add
+      # @param exp [String] The sql expresssion to modify
+      def date_add(unit, val, exp)
+        gsk(:date_add)
+          .gsub(/@unit/i, unit)
+          .gsub(/@val/i, val.to_s)
+          .gsub(/@exp/i, exp)
+      end
+    end
+  end
+end

data/lib/dwh/adapters/sql_server.rb

@@ -142,7 +142,7 @@ module DWH
         change_current_database(db_table.catalog)
 
         schema_where = ''
-        schema_where = "AND table_schema = '#{db_table.schema}'" if db_table.schema.present?
+        schema_where = "AND table_schema = '#{db_table.schema}'" if db_table.schema?
 
         sql = <<-SQL
                     SELECT column_name, data_type, character_maximum_length, numeric_precision,numeric_scale
@@ -234,7 +234,13 @@ module DWH
         super
         require 'tiny_tds'
       rescue LoadError
-        raise ConfigError, "Required 'tiny_tds' gem missing. Please add it to your Gemfile."
+        raise ConfigError, <<~MSG
+          SQL Server adapter requires the 'tiny_tds' gem.
+
+          Install with: gem install tiny_tds
+
+          System libraries (FreeTDS): https://www.freetds.org/
+        MSG
       end
 
       private

data/lib/dwh/adapters/sqlite.rb

@@ -0,0 +1,364 @@
+module DWH
+  module Adapters
+    # SQLite adapter optimized for analytical workloads.
+    #
+    # This requires the ruby {https://github.com/sparklemotion/sqlite3-ruby sqlite3} gem.
+    #
+    # Generally, adapters should be created using {DWH::Factory#create DWH.create}. Where a configuration
+    # is passed in as options hash or argument list.
+    #
+    # @example Basic connection with required only options
+    #   DWH.create(:sqlite, {file: 'path/to/my/database.db' })
+    #
+    # @example Open in read only mode
+    #   DWH.create(:sqlite, {file: 'path/to/my/database.db', readonly: true})
+    #
+    # @example Configure with custom performance pragmas
+    #   DWH.create(:sqlite, {file: 'path/to/my/database.db',
+    #     pragmas: { cache_size: -128000, mmap_size: 268435456 }})
+    #
+    # @note This adapter enables WAL mode by default for better concurrent read performance.
+    #   Set `enable_wal: false` to disable this behavior.
+    class Sqlite < Adapter
+      config :file, String, required: true, message: 'path/to/sqlite/db'
+      config :readonly, Boolean, required: false, default: false, message: 'open database in read-only mode'
+      config :enable_wal, Boolean, required: false, default: true, message: 'enable WAL mode for better concurrency'
+      config :pragmas, Hash, required: false, message: 'hash of PRAGMA statements for performance tuning'
+      config :timeout, Integer, required: false, default: 5000, message: 'busy timeout in milliseconds'
+
+      # Default pragmas optimized for analytical workloads
+      DEFAULT_PRAGMAS = {
+        cache_size: -64_000, # 64MB cache (negative means KB)
+        temp_store: 'MEMORY', # Store temp tables in memory
+        mmap_size: 134_217_728, # 128MB memory-mapped I/O
+        page_size: 4096,         # Standard page size
+        synchronous: 'NORMAL'    # Faster than FULL, safe with WAL
+      }.freeze
+
+      # (see Adapter#connection)
+      def connection
+        return @connection if @connection
+
+        options = build_open_options
+        @connection = SQLite3::Database.new(config[:file], options)
+
+        # Set busy timeout to handle concurrent access
+        @connection.busy_timeout(config[:timeout])
+
+        # Don't return results as hash by default for performance
+        @connection.results_as_hash = false
+
+        # Enable WAL mode for concurrent reads (unless disabled or readonly)
+        @connection.execute('PRAGMA journal_mode = WAL') if config[:enable_wal] && !config[:readonly]
+
+        # Apply default pragmas
+        apply_pragmas(DEFAULT_PRAGMAS)
+
+        # Apply user-specified pragmas (will override defaults)
+        apply_pragmas(config[:pragmas]) if config.key?(:pragmas)
+
+        @connection
+      rescue StandardError => e
+        raise ConfigError, e.message
+      end
+
+      # (see Adapter#close)
+      def close
+        return if @connection.nil?
+
+        @connection.close unless @connection.closed?
+        @connection = nil
+      end
+
+      # (see Adapter#test_connection)
+      def test_connection(raise_exception: false)
+        connection
+        connection.execute('SELECT 1')
+        true
+      rescue StandardError => e
+        raise ConnectionError, e.message if raise_exception
+
+        false
+      end
+
+      # (see Adapter#tables)
+      def tables(**qualifiers)
+        sql = "SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%' ORDER BY name"
+
+        res = execute(sql)
+        res.flatten
+      end
+
+      # (see Adapter#stats)
+      def stats(table, date_column: nil, **qualifiers)
+        db_table = Table.new table, **qualifiers
+
+        sql = <<-SQL
+        SELECT count(*) AS ROW_COUNT
+        #{date_column.nil? ? '' : ", min(#{date_column}) AS DATE_START"}
+        #{date_column.nil? ? '' : ", max(#{date_column}) AS DATE_END"}
+        FROM #{db_table.physical_name}
+        SQL
+
+        result = execute(sql)
+        TableStats.new(
+          row_count: result.first[0],
+          date_start: date_column ? result.first[1] : nil,
+          date_end: date_column ? result.first[2] : nil
+        )
+      end
+
+      # (see Adapter#metadata)
+      def metadata(table, **qualifiers)
+        db_table = Table.new table, **qualifiers
+
+        # SQLite uses PRAGMA table_info for metadata
+        sql = "PRAGMA table_info(#{db_table.physical_name})"
+
+        cols = execute(sql)
+        cols.each do |col|
+          # PRAGMA table_info returns: cid, name, type, notnull, dflt_value, pk
+          db_table << Column.new(
+            name: col[1],
+            data_type: col[2],
+            precision: nil,
+            scale: nil,
+            max_char_length: nil
+          )
+        end
+
+        db_table
+      end
+
+      # (see Adapter#execute)
+      def execute(sql, format: :array, retries: 0)
+        begin
+          result = with_debug(sql) { with_retry(retries) { connection.execute(sql) } }
+        rescue StandardError => e
+          raise ExecutionError, e.message
+        end
+
+        format = format.downcase if format.is_a?(String)
+        case format.to_sym
+        when :array
+          result
+        when :object
+          result_to_hash(sql, result)
+        when :csv
+          result_to_csv(sql, result)
+        when :native
+          result
+        else
+          raise UnsupportedCapability, "Unsupported format: #{format} for this #{name}"
+        end
+      end
+
+      # (see Adapter#execute_stream)
+      def execute_stream(sql, io, stats: nil, retries: 0)
+        with_debug(sql) do
+          with_retry(retries) do
+            stmt = connection.prepare(sql)
+            columns = stmt.columns
+
+            io.write(CSV.generate_line(columns))
+
+            stmt.execute.each do |row|
+              stats << row unless stats.nil?
+              io.write(CSV.generate_line(row))
+            end
+
+            stmt.close
+          end
+        end
+
+        io.rewind
+        io
+      rescue StandardError => e
+        raise ExecutionError, e.message
+      end
+
+      # (see Adapter#stream)
+      def stream(sql, &block)
+        with_debug(sql) do
+          stmt = connection.prepare(sql)
+          stmt.execute.each do |row|
+            block.call(row)
+          end
+          stmt.close
+        end
+      end
+
+      # Custom date truncation implementation. SQLite doesn't offer
+      # a native DATE_TRUNC function. We use 'start of' modifiers
+      # for year, month, and day, and custom logic for quarter and week.
+      # @see Dates#truncate_date
+      def truncate_date(unit, exp)
+        unit = unit.strip.downcase
+
+        case unit
+        when 'year'
+          "date(#{exp}, 'start of year')"
+        when 'quarter'
+          # Calculate quarter start using CASE statement
+          # Q1: Jan-Mar (months 1-3) -> start of year
+          # Q2: Apr-Jun (months 4-6) -> start of year + 3 months
+          # Q3: Jul-Sep (months 7-9) -> start of year + 6 months
+          # Q4: Oct-Dec (months 10-12) -> start of year + 9 months
+          '(CASE ' \
+          "WHEN CAST(strftime('%m', #{exp}) AS INTEGER) BETWEEN 1 AND 3 THEN date(#{exp}, 'start of year') " \
+          "WHEN CAST(strftime('%m', #{exp}) AS INTEGER) BETWEEN 4 AND 6 THEN date(#{exp}, 'start of year', '+3 months') " \
+          "WHEN CAST(strftime('%m', #{exp}) AS INTEGER) BETWEEN 7 AND 9 THEN date(#{exp}, 'start of year', '+6 months') " \
+          "ELSE date(#{exp}, 'start of year', '+9 months') " \
+          'END)'
+        when 'month'
+          "date(#{exp}, 'start of month')"
+        when 'week'
+          # Use week start day from settings
+          gsk("#{settings[:week_start_day].downcase}_week_start_day")
+            .gsub(/@exp/i, exp)
+        when 'day', 'date'
+          "date(#{exp})"
+        when 'hour'
+          # SQLite datetime returns timestamp, truncate to hour
+          "datetime(strftime('%Y-%m-%d %H:00:00', #{exp}))"
+        when 'minute'
+          "datetime(strftime('%Y-%m-%d %H:%M:00', #{exp}))"
+        when 'second'
+          "datetime(strftime('%Y-%m-%d %H:%M:%S', #{exp}))"
+        else
+          raise UnsupportedCapability, "Currently not supporting truncation at #{unit} level"
+        end
+      end
+
+      # SQLite's strftime doesn't support %A (day name) or %B (month name)
+      # We need to implement these using CASE statements based on day/month numbers
+      def extract_day_name(exp, abbreviate: false)
+        day_num = "CAST(strftime('%w', #{exp}) AS INTEGER)"
+
+        if abbreviate
+          # Abbreviated day names: SUN, MON, TUE, etc.
+          "(CASE #{day_num} " \
+          "WHEN 0 THEN 'SUN' " \
+          "WHEN 1 THEN 'MON' " \
+          "WHEN 2 THEN 'TUE' " \
+          "WHEN 3 THEN 'WED' " \
+          "WHEN 4 THEN 'THU' " \
+          "WHEN 5 THEN 'FRI' " \
+          "WHEN 6 THEN 'SAT' " \
+          'END)'
+        else
+          # Full day names: SUNDAY, MONDAY, TUESDAY, etc.
+          "(CASE #{day_num} " \
+          "WHEN 0 THEN 'SUNDAY' " \
+          "WHEN 1 THEN 'MONDAY' " \
+          "WHEN 2 THEN 'TUESDAY' " \
+          "WHEN 3 THEN 'WEDNESDAY' " \
+          "WHEN 4 THEN 'THURSDAY' " \
+          "WHEN 5 THEN 'FRIDAY' " \
+          "WHEN 6 THEN 'SATURDAY' " \
+          'END)'
+        end
+      end
+
+      def extract_month_name(exp, abbreviate: false)
+        month_num = "CAST(strftime('%m', #{exp}) AS INTEGER)"
+
+        if abbreviate
+          # Abbreviated month names: JAN, FEB, MAR, etc.
+          "(CASE #{month_num} " \
+          "WHEN 1 THEN 'JAN' " \
+          "WHEN 2 THEN 'FEB' " \
+          "WHEN 3 THEN 'MAR' " \
+          "WHEN 4 THEN 'APR' " \
+          "WHEN 5 THEN 'MAY' " \
+          "WHEN 6 THEN 'JUN' " \
+          "WHEN 7 THEN 'JUL' " \
+          "WHEN 8 THEN 'AUG' " \
+          "WHEN 9 THEN 'SEP' " \
+          "WHEN 10 THEN 'OCT' " \
+          "WHEN 11 THEN 'NOV' " \
+          "WHEN 12 THEN 'DEC' " \
+          'END)'
+        else
+          # Full month names: JANUARY, FEBRUARY, MARCH, etc.
+          "(CASE #{month_num} " \
+          "WHEN 1 THEN 'JANUARY' " \
+          "WHEN 2 THEN 'FEBRUARY' " \
+          "WHEN 3 THEN 'MARCH' " \
+          "WHEN 4 THEN 'APRIL' " \
+          "WHEN 5 THEN 'MAY' " \
+          "WHEN 6 THEN 'JUNE' " \
+          "WHEN 7 THEN 'JULY' " \
+          "WHEN 8 THEN 'AUGUST' " \
+          "WHEN 9 THEN 'SEPTEMBER' " \
+          "WHEN 10 THEN 'OCTOBER' " \
+          "WHEN 11 THEN 'NOVEMBER' " \
+          "WHEN 12 THEN 'DECEMBER' " \
+          'END)'
+        end
+      end
+
+      # SQLite's CAST(... AS DATE) doesn't work properly - it just extracts the year
+      # We need to override cast to use the date() function for DATE types
+      def cast(exp, type)
+        if type.to_s.downcase == 'date'
+          "date(#{exp})"
+        else
+          super
+        end
+      end
+
+      def valid_config?
+        super
+        require 'sqlite3'
+      rescue LoadError
+        raise ConfigError, "Required 'sqlite3' gem missing. Please add it to your Gemfile."
+      end
+
+      private
+
+      def build_open_options
+        options = {}
+        options[:readonly] = true if config[:readonly]
+        options
+      end
+
+      def apply_pragmas(pragmas)
+        return unless pragmas
+
+        pragmas.each do |pragma, value|
+          # Format value appropriately (quote strings, leave numbers/keywords as-is)
+          formatted_value = value.is_a?(String) && value.upcase != value ? "'#{value}'" : value
+          @connection.execute("PRAGMA #{pragma} = #{formatted_value}")
+        end
+      end
+
+      def result_to_hash(sql, result)
+        return [] if result.empty?
+
+        # Get column names by preparing statement
+        stmt = connection.prepare(sql)
+        columns = stmt.columns
+        stmt.close
+
+        result.map do |row|
+          columns.zip(row).to_h
+        end
+      end
+
+      def result_to_csv(sql, result)
+        # Get column names by preparing statement
+        stmt = connection.prepare(sql)
+        columns = stmt.columns
+        stmt.close
+
+        CSV.generate do |csv|
+          csv << columns
+          result.each do |row|
+            csv << row
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dwh/adapters/trino.rb

@@ -194,7 +194,13 @@ module DWH
         super
         require 'trino-client'
       rescue LoadError
-        raise ConfigError, "Required 'trino-client' gem missing. Please add it to your Gemfile."
+        raise ConfigError, <<~MSG
+          Trino adapter requires the 'trino-client' gem.
+
+          Install with: gem install trino-client
+
+          No system libraries required (pure Ruby).
+        MSG
       end
 
       private

data/lib/dwh/adapters.rb

@@ -80,12 +80,12 @@ module DWH
       attr_reader :config
 
       def initialize(config)
-        @config = config.symbolize_keys
+        @config = config.transform_keys(&:to_sym)
         # Per instance customization of general settings
         # So you can have multiple connections to Trino
         # but exhibit diff behavior
         @settings = self.class.adapter_settings.merge(
-          (config[:settings] || {}).symbolize_keys
+          (config[:settings] || {}).transform_keys(&:to_sym)
         )
 
         valid_config?
@@ -300,7 +300,7 @@ module DWH
       # Adapter name from the class name
       # @return [String]
       def adapter_name
-        self.class.name.demodulize
+        self.class.name.split('::').last.downcase
       end
 
       # If any extra connection params were passed in the config

data/lib/dwh/column.rb

@@ -22,7 +22,7 @@ module DWH
 
     DEFAULT_RULES = { /[_+]+/ => ' ', /\s+id$/i => ' ID', /desc/i => 'Description' }.freeze
     def namify(rules = DEFAULT_RULES)
-      named = name.titleize keep_id_suffix: true
+      named = titleize(name)
       rules.each do |k, v|
         named = named.gsub(Regexp.new(k), v)
       end
@@ -75,5 +75,16 @@ module DWH
     def to_s
       "<Column:#{name}:#{data_type}>"
     end
+
+    def titleize(name)
+      # Handle underscores, dashes, and multiple spaces
+      # Also preserves existing spacing patterns better
+      name.gsub(/[_-]/, ' ')           # Convert underscores and dashes to spaces
+          .gsub(/\s+/, ' ')            # Normalize multiple spaces to single spaces
+          .strip                       # Remove leading/trailing whitespace
+          .split(' ')                  # Split into words
+          .map(&:capitalize)           # Capitalize each word
+          .join(' ')                   # Join with single spaces
+    end
   end
 end

data/lib/dwh/functions/dates.rb

@@ -124,12 +124,27 @@ module DWH
         gsk(:date_literal).gsub(/@val/i, val)
       end
 
+      # @see #date_literal
+      def date_lit(val)
+        date_literal(val)
+      end
+
       # @param val [String, Date, DateTime, Time]
       def date_time_literal(val)
         val = DATE_CLASSES.include?(val.class) ? val.strftime(date_time_format) : val
         gsk(:date_time_literal).gsub(/@val/i, val)
       end
 
+      # @see #date_time_literal
+      def timestamp_lit(val)
+        date_time_literal(val)
+      end
+
+      # @see #date_time_literal
+      def timestamp_literal(val)
+        date_time_literal(val)
+      end
+
       # The current default week start day. This is how
       # the db is currently setup.  Should be either monday or sunday
       def default_week_start_day

data/lib/dwh/settings/databricks.yml

@@ -1,6 +1,5 @@
-
 # quotes and string lit
-quote: "\"@exp\""
+quote: "`@exp`"
 string_literal: "'@exp'"
 
 # Date Literal Formats
@@ -13,20 +12,20 @@ abbreviated_day_name_format: "EEE"
 month_name_format: "MMMM"
 abbreviated_month_name_format: "MMM"
 
-date_add: "date_add(@unit, @val, @exp)"
-date_diff: "date_diff(@unit, @start_exp, @end_exp)"
-date_format_sql: "date_format(@exp, '@format')"
-extract_day_of_year: 'dayofyear(@exp)'
-extract_day_of_week: 'dayofweek(@exp)'
-extract_week_of_year: 'weekofyear(@exp)'
-extract_year_month: 'cast(concat(year(@exp), lpad(month(@exp), 2, "0")) as int)'
+date_add: "DATE_ADD(@unit, @val, @exp)"
+date_diff: "DATE_DIFF(@unit, @start_exp, @end_exp)"
+date_format_sql: "DATE_FORMAT(@exp, '@format')"
+extract_day_of_year: 'DAYOFYEAR(@exp)'
+extract_day_of_week: 'DAYOFWEEK(@exp)'
+extract_week_of_year: 'WEEKOFYEAR(@exp)'
+extract_year_month: 'CAST(CONCAT(YEAR(@exp), LPAD(MONTH(@exp), 2, "0")) as INT)'
 
 cast: "CAST(@exp AS @type)"
 
 # string functions
-trim: "trim(@exp)"
-lower_case: "lower(@exp)"
-upper_case: "upper(@exp)"
+trim: "TRIM(@exp)"
+lower_case: "LOWER(@exp)"
+upper_case: "UPPER(@exp)"
 
 # null handling
 if_null: "COALESCE(@exp, @when_null)"
@@ -45,7 +44,7 @@ supports_window_functions: true
 extend_ending_date_to_last_hour_of_day: false # druid needs this for inclusive filtering
 
 # array operations
-array_in_list: "exists(@exp, x -> x IN (@list))"
-array_exclude_list: "not exists(@exp, x -> x IN (@list))"
-array_unnest_join: "LATERAL VIEW explode(@exp) AS @alias"
+array_in_list: "EXISTS(@exp, x -> x IN (@list))"
+array_exclude_list: "NOT EXISTS(@exp, x -> x IN (@list))"
+array_unnest_join: "LATERAL VIEW EXPLODE(@exp) AS @alias"
 

data/lib/dwh/settings/druid.yml

@@ -25,9 +25,9 @@ sunday_week_start_day: "TIME_FLOOR(@exp, 'P7D', TIMESTAMP '1970-01-04 00:00:00')
 monday_week_start_day: "TIME_FLOOR(@exp, 'P7D', TIMESTAMP '1970-01-05 00:00:00')"
 
 # string functions
-trim: "trim(@exp)"
-lower_case: "lower(@exp)"
-upper_case: "upper(@exp)"
+trim: "TRIM(@exp)"
+lower_case: "LOWER(@exp)"
+upper_case: "UPPER(@exp)"
 
 # Relevant db capabilities
 supports_table_join: true

data/lib/dwh/settings/duckdb.yml

@@ -38,7 +38,7 @@ upper_case: "UPPER(@exp)"
 create_temp_table_template: "CREATE TEMP TABLE @table AS \n@sql"
 
 # array operations
-array_in_list: "array_length(array_intersect(@exp, @list)) > 0"
-array_exclude_list: "array_length(array_intersect(@exp, @list)) = 0"
+array_in_list: "ARRAY_LENGTH(ARRAY_INTERSECT(@exp, @list)) > 0"
+array_exclude_list: "ARRAY_LENGTH(ARRAY_INTERSECT(@exp, @list)) = 0"
 array_unnest_join: ", LATERAL (SELECT UNNEST(@exp)) AS @alias"