dwh 0.1.0 → 0.2.0

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.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
@@ -335,7 +335,7 @@ module DWH
 
         # Check for missing required parameters
         missing_params = definitions.select do |name, options|
-          options[:required] && !config.key?(name) && options[:default].nil?
+          options[:required] && !config[name] && options[:default].nil?
         end
 
         if missing_params.any?
@@ -351,7 +351,7 @@ module DWH
 
           raise ConfigError, "Invalid value. Only allowed: #{opts[:allowed]}." if opts[:allowed].any? && !opts[:allowed].include?(config[name])
 
-          config[name] = opts[:default] if opts[:default] && !config.key?(name)
+          config[name] = opts[:default] if opts[:default] && !config[name]
 
           if opts[:required] && !config[name].is_a?(opts[:type]) && !opts[:type].is_a?(Boolean)
             raise ConfigError, "#{name} should be a #{opts[:type]}. Got #{opts[name.to_sym].class.name}"

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

@@ -13,20 +13,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 +45,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"
 

data/lib/dwh/settings/mysql.yml

@@ -24,8 +24,8 @@ extract_minute: 'MINUTE(@exp)'
 extract_year_month: 'CAST(CONCAT(YEAR(@exp), LPAD(MONTH(@exp), 2, "0")) AS UNSIGNED)'
 default_week_start_day: "sunday"
 week_start_day: "monday"
-sunday_week_start_day: "DATE(DATE_SUB(@exp, INTERVAL dayofweek(@exp)-1 DAY ))"
-monday_week_start_day: "DATE(DATE_SUB(@exp, INTERVAL dayofweek(@exp)-2 DAY ))"
+sunday_week_start_day: "DATE(DATE_SUB(@exp, INTERVAL DAYOFWEEK(@exp)-1 DAY ))"
+monday_week_start_day: "DATE(DATE_SUB(@exp, INTERVAL DAYOFWEEK(@exp)-2 DAY ))"
 cast: "CAST(@exp AS @type)"
 
 # string functions

data/lib/dwh/settings/postgres.yml

@@ -1,6 +1,6 @@
 
 date_add: "(@exp + '@val @unit'::interval)"
-date_diff: "age(@start_exp, @end_exp)"
+date_diff: "AGE(@start_exp, @end_exp)"
 date_format_sql: "TO_CHAR(@exp, '@format')"
 date_literal: "'@val'::DATE"
 date_time_literal: "'@val'::TIMESTAMP"
@@ -12,16 +12,16 @@ abbreviated_month_name_format: "Mon"
 sunday_week_start_day: "( DATE_TRUNC('WEEK', @exp + INTERVAL '1 DAY') - INTERVAL '1 DAY' )"
 monday_week_start_day: "( DATE_TRUNC('WEEK', @exp - INTERVAL '1 DAY') + INTERVAL '1 DAY' )"
 
-extract_year: 'extract(year from @exp)'
-extract_month: 'extract(month from @exp)'
-extract_quarter: 'extract(quarter from @exp)'
-extract_day_of_year: 'extract(DOY from @exp)'
-extract_day_of_month: 'extract(DAY from @exp)'
-extract_day_of_week: 'extract(DOW from @exp)'
-extract_week_of_year: 'extract(WEEK from @exp)'
-extract_hour: 'extract(HOUR from @exp)'
-extract_minute: 'extract(MINUTE from @exp)'
-extract_year_month: "cast((extract(year from @exp)::varchar || TO_CHAR(@exp, 'MM')) as integer)"
+extract_year: 'EXTRACT(year from @exp)'
+extract_month: 'EXTRACT(month from @exp)'
+extract_quarter: 'EXTRACT(quarter from @exp)'
+extract_day_of_year: 'EXTRACT(DOY from @exp)'
+extract_day_of_month: 'EXTRACT(DAY from @exp)'
+extract_day_of_week: 'EXTRACT(DOW from @exp)'
+extract_week_of_year: 'EXTRACT(WEEK from @exp)'
+extract_hour: 'EXTRACT(HOUR from @exp)'
+extract_minute: 'EXTRACT(MINUTE from @exp)'
+extract_year_month: "CAST((EXTRACT(YEAR FROM @exp)::varchar || TO_CHAR(@exp, 'MM')) as INTEGER)"
 
 cast: "@exp::@type"
 

data/lib/dwh/settings/redshift.yml

@@ -1,28 +1,19 @@
-
-# quotes and string lit
-quote: "\"@exp\""
-string_literal: "'@exp'"
-
 # Date Literal Formats
-date_format: "%Y-%m-%d"
-date_time_format: "%Y-%m-%d %H:%M:%S"
-date_time_tz_format: "%Y-%m-%d %H:%M:%S %Z"
-date_type: "string" # alternative is int, integer, dateint
 day_name_format: "Day"
 abbreviated_day_name_format: "Dy"
 month_name_format: "Month" 
 abbreviated_month_name_format: "Mon"
 
 # Date functions patterns
-current_date: "current_date"
-current_time: "current_time"
-current_timestamp: "current_timestamp"
-truncate_date: "date_trunc('@unit', @exp)"
-date_add: "dateadd(@unit, @val, @exp)"
-date_diff: "datediff(@unit, @start_exp, @end_exp)"
+current_date: "CURRENT_DATE"
+current_time: "CURRENT_TIME"
+current_timestamp: "CURRENT_TIMESTAMP"
+truncate_date: "DATE_TRUNC('@unit', @exp)"
+date_add: "DATEADD(@unit, @val, @exp)"
+date_diff: "DATEDIFF(@unit, @start_exp, @end_exp)"
 date_format_sql: "TO_CHAR(@exp, '@format')"
-date_literal: "'@val'"
-date_time_literal: "TIMESTAMP '@val'"
+date_literal: "'@val'::DATE"
+date_time_literal: "'@val'::TIMESTAMP"
 extract_year: 'EXTRACT(YEAR FROM @exp)'
 extract_month: 'EXTRACT(MONTH FROM @exp)'
 extract_quarter: 'EXTRACT(QUARTER FROM @exp)'
@@ -33,15 +24,15 @@ extract_week_of_year: 'EXTRACT(WEEK FROM @exp)'
 extract_hour: 'EXTRACT(HOUR FROM @exp)'
 extract_minute: 'EXTRACT(MINUTE FROM @exp)'
 extract_year_month: "TO_CHAR(@exp, 'YYYYMM')::INTEGER"
-default_week_start_day: "sunday" # Redshift uses Sunday as default
-week_start_day: "sunday"
-sunday_week_start_day: "DATEADD(day, -1, DATE_TRUNC(WEEK, DATEADD(DAY, 1, @exp)))"
-monday_week_start_day: "DATEADD(day, 1, DATE_TRUNC(WEEK, DATEADD(day, -1, @exp)))"
+default_week_start_day: "monday" # Redshift uses Sunday as default
+week_start_day: "monday"
+sunday_week_start_day: "DATEADD(day, -1, DATE_TRUNC('WEEK', DATEADD(DAY,  1, @exp)))"
+monday_week_start_day: "DATEADD(day,  1, DATE_TRUNC('WEEK', DATEADD(day, -1, @exp)))"
 
 # 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)"