dwh 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1d0cb4848d96ff20f5b4c80e00cbfde5f1150e0e975cf55827f8466b9d4eaf49
-  data.tar.gz: ce79d54a93388718886c8ec7892e9da544c4ddc52333e1a765a742518552df69
+  metadata.gz: 899fb3e403f0362cb21132d9af44f622e870b339776aac7bd4d3e7ed333d59e4
+  data.tar.gz: a3d536eb6da5885d4817be013d80e6b5a5ed422bce1466ac582c2b478724e278
 SHA512:
-  metadata.gz: e61d14edd0b8e5818eb2eb3fe5ec25adf69a49279c9fd8b8db0ddb271f746de30573d97d90a6fe3bb9acf350f2ad80a72f076a19bd72a1270d9418aee6eca320
-  data.tar.gz: a53cc7c72c222b579777e7796bbdefeada81ac77a8bf12d5ab46be73e2d76b7721deba91deb2019597013a1f1a46173a7406d6d95d1f8d11eb53f62e7ba19b26
+  metadata.gz: 5703c4ee14bf336b92f15740bfd0a6bce086ac9b636d67bcf269ea337a550a80bdd6a2f9d4265dd0a476d8d693a313dd2e6c8fa2fc587ea0f4653f6e0b528860
+  data.tar.gz: fa72a56f3eac7c5b4eae524a70b002f93b23e54513209d182de92e119aa43ea57a08d31d0f183b19d7df36601472045d9d2a001b26dda8bd56ee886556d4b21e

data/CHANGELOG.md

@@ -1,5 +1,36 @@
 ## [Unreleased]
 
+## [0.2.0] - 2025-10-12
+
+### Added
+
+- **SQLite adapter** with performance optimizations
+  - WAL (Write-Ahead Logging) mode enabled by default for concurrent reads
+  - Performance-tuned pragmas: cache_size, mmap_size, temp_store, synchronous
+  - Custom date truncation for year, quarter, month, week, day, hour, minute, second
+  - Custom day/month name extraction via CASE statements (SQLite lacks strftime %A/%B support)
+  - Proper date casting using `date()` function
+  - Comprehensive test suite and documentation
+- **Redshift adapter** for AWS data warehouse
+  - Native Redshift SQL function support
+  - Full metadata and table introspection
+- `date_time_literal` method for creating timestamp literals
+- `date_lit` method for creating date literals
+
+### Changed
+
+- Removed ActiveSupport dependency
+  - Replaced `symbolize_keys` with `transform_keys(&:to_sym)`
+  - Replaced `demodulize` with `split('::').last.downcase`
+  - Removed core extensions
+- Standardized all SQL function names in settings to UPPERCASE for consistency
+
+### Fixed
+
+- Config defaults now properly set even when config key is passed with nil value
+- Table instantiation issues resolved
+- Test suite no longer requires Trino gem for default tests
+
 ## [0.1.0] - 2025-07-03
 
 - Initial release

data/README.md

@@ -25,16 +25,17 @@ The adapter only has 5 core methods (6 including the connection method).  A YAML
 
 - **Snowflake** - High performance cloud warehouse
 - **Trino** (formerly Presto) - Distributed SQL query engine
+- **Redshift** - AWS data warehouse platform
 - **AWS Athena** - AWS big data warehouse
 - **Apache Druid** - Real-time analytics database
 - **DuckDB** - In-process analytical database
+- **SQLite** - Lightweight embedded database
 - **PostgreSQL** - Full-featured RDBMS with advanced SQL support
 - **MySQL** - Popular open-source database
 - **SQL Server** - Microsoft's enterprise database
 
 ## Integrations Coming Soon
 
-- **Redshift** - AWS data warehouse platform
 - **ClickHouse** - High performance analytical db
 - **Databricks** - Big data compute engine
 - **MotherDuck** - Hosted DuckDB service
@@ -61,6 +62,14 @@ druid = DWH.create(:druid, {
 
 # basic query execution
 results = druid.execute("SELECT * FROM web_sales", format: :csv)
+
+# Connect to SQLite for local analytics
+sqlite = DWH.create(:sqlite, {
+  file: 'path/to/analytics.db'
+})
+
+# Query with optimized WAL mode enabled by default
+results = sqlite.execute("SELECT * FROM sales_data", format: :array)
 ```
 
 ## Core API

data/docs/guides/adapters.md

@@ -70,6 +70,71 @@ postgres = DWH.create(:postgres, {
 })
 ```
 
+## Redshift Adapter
+
+The Redshift adapter uses the `pg` gem and provides full-featured RDBMS support.
+
+### Basic Configuration
+
+```ruby
+redshift = DWH.create(:redshift, {
+  host: 'localhost',
+  port: 5432,                    # Default: 5432
+  database: 'mydb',
+  schema: 'public',              # Default: 'public'
+  username: 'user',
+  password: 'password',
+  client_name: 'My Application'  # Default: 'DWH Ruby Gem'
+})
+```
+
+### SSL Configuration
+
+```ruby
+# Basic SSL
+redshift = DWH.create(:redshift, {
+  host: 'localhost',
+  database: 'mydb',
+  username: 'user',
+  password: 'password',
+  ssl: true,
+  extra_connection_params: {
+    sslmode: 'require'  # disable, prefer, require, verify-ca, verify-full
+  }
+})
+
+# Certificate-based SSL
+redshift = DWH.create(:postgres, {
+  host: 'localhost',
+  database: 'mydb',
+  username: 'user',
+  ssl: true,
+  extra_connection_params: {
+    sslmode: 'verify-full',
+    sslrootcert: '/path/to/ca-cert.pem',
+    sslcert: '/path/to/client-cert.pem',
+    sslkey: '/path/to/client-key.pem'
+  }
+})
+```
+
+### Advanced Configuration
+
+```ruby
+redshift = DWH.create(:redshift, {
+  host: 'localhost',
+  database: 'mydb',
+  username: 'user',
+  password: 'password',
+  query_timeout: 3600,  # seconds, default: 3600
+  extra_connection_params: {
+    application_name: 'Data Analysis Tool',
+    connect_timeout: 10,
+    options: '-c maintenance_work_mem=256MB'
+  }
+})
+```
+
 ## Snowflake
 
 Snowflake adapter use the REST apis (https) to connect and query. This adapter also supports Multi-Database
@@ -287,6 +352,99 @@ duckdb = DWH.create(:duckdb, {
 })
 ```
 
+## SQLite Adapter
+
+The SQLite adapter uses the `sqlite3` gem for lightweight embedded database analytics. It's optimized for analytical workloads with WAL mode enabled by default for better concurrent read performance.
+
+### Basic Configuration
+
+```ruby
+# File-based database
+sqlite = DWH.create(:sqlite, {
+  file: '/path/to/my/database.sqlite'
+})
+
+# In-memory database
+sqlite = DWH.create(:sqlite, {
+  file: ':memory:'
+})
+```
+
+### Read-Only Mode
+
+```ruby
+sqlite = DWH.create(:sqlite, {
+  file: '/path/to/readonly/database.sqlite',
+  readonly: true
+})
+```
+
+### Performance Optimization
+
+The adapter includes default optimizations for analytical workloads:
+- WAL mode enabled by default for concurrent reads
+- 64MB cache size
+- Memory-mapped I/O (128MB)
+- Temp tables stored in memory
+
+```ruby
+# Customize performance settings
+sqlite = DWH.create(:sqlite, {
+  file: '/path/to/my/database.sqlite',
+  timeout: 5000,  # busy timeout in milliseconds, default: 5000
+  pragmas: {
+    cache_size: -128000,      # 128MB cache (negative means KB)
+    mmap_size: 268435456,     # 256MB memory-mapped I/O
+    temp_store: 'MEMORY',     # Store temp tables in memory
+    synchronous: 'NORMAL'     # Faster than FULL, safe with WAL
+  }
+})
+```
+
+### Disable WAL Mode
+
+```ruby
+# Disable WAL mode if needed (e.g., for NFS or network filesystems)
+sqlite = DWH.create(:sqlite, {
+  file: '/path/to/my/database.sqlite',
+  enable_wal: false
+})
+```
+
+### Advanced Configuration
+
+```ruby
+sqlite = DWH.create(:sqlite, {
+  file: '/path/to/analytics.sqlite',
+  readonly: false,
+  enable_wal: true,           # Default: true
+  timeout: 10000,             # 10 second busy timeout
+  pragmas: {
+    journal_mode: 'WAL',      # Explicitly set WAL (done by default)
+    cache_size: -256000,      # 256MB cache
+    page_size: 8192,          # Larger page size for analytics
+    mmap_size: 536870912,     # 512MB memory-mapped I/O
+    temp_store: 'MEMORY',     # Keep temp data in memory
+    synchronous: 'NORMAL',    # Balance between safety and speed
+    locking_mode: 'NORMAL'    # Allow multiple connections
+  }
+})
+```
+
+### Multiple Connections
+
+Unlike DuckDB, SQLite allows multiple independent connections to the same database file:
+
+```ruby
+# Multiple readers/writers to the same file
+reader = DWH.create(:sqlite, { file: '/path/to/data.sqlite', readonly: true })
+writer = DWH.create(:sqlite, { file: '/path/to/data.sqlite' })
+
+# Both can operate concurrently with WAL mode enabled
+data = reader.execute('SELECT * FROM sales')
+writer.execute('INSERT INTO sales VALUES (...)')
+```
+
 ## Trino Adapter
 
 The Trino adapter requires the `trino-client-ruby` gem and works with both Trino and Presto.

data/docs/guides/getting-started.md

@@ -40,9 +40,14 @@ postgres = DWH.create(:postgres, {
   password: 'password'
 })
 
+# Connect to SQLite (lightweight, embedded)
+sqlite = DWH.create(:sqlite, {
+  file: '/path/to/analytics.db'
+})
+
 # Connect to DuckDB (in-memory)
 duckdb = DWH.create(:duckdb, {
-  database: ':memory:'
+  file: ':memory:'
 })
 ```
 

data/docs/guides/usage.md

@@ -293,7 +293,7 @@ native = adapter.execute(sql, format: :native)   # Database's native format
 # Use streaming for large result sets
 def export_large_table(adapter, table_name, output_file)
   query = "SELECT * FROM #{table_name}"
-  
+
   File.open(output_file, 'w') do |file|
     adapter.execute_stream(query, file)
   end
@@ -309,6 +309,38 @@ def process_large_dataset(adapter, query)
 end
 ```
 
+### SQLite Performance Tuning
+
+SQLite adapter comes with optimized defaults for analytical workloads, but can be further tuned:
+
+```ruby
+# High-performance SQLite configuration for analytics
+sqlite = DWH.create(:sqlite, {
+  file: '/path/to/large_analytics.db',
+  enable_wal: true,           # WAL mode for concurrent reads (default: true)
+  timeout: 30000,             # 30 second busy timeout for heavy writes
+  pragmas: {
+    cache_size: -512000,      # 512MB cache for large datasets
+    page_size: 8192,          # Larger pages for sequential scans
+    mmap_size: 1073741824,    # 1GB memory-mapped I/O
+    temp_store: 'MEMORY',     # Keep temp tables in RAM
+    synchronous: 'NORMAL',    # Balance safety/speed (safe with WAL)
+    journal_size_limit: 67108864  # 64MB journal limit
+  }
+})
+
+# Read-only analytics queries with maximum performance
+readonly_analytics = DWH.create(:sqlite, {
+  file: '/path/to/data.db',
+  readonly: true,             # Read-only for maximum concurrency
+  pragmas: {
+    cache_size: -256000,      # 256MB cache
+    mmap_size: 2147483648,    # 2GB memory mapping for large files
+    temp_store: 'MEMORY'      # Fast temp operations
+  }
+})
+```
+
 ## Error Handling and Debugging
 
 ### Comprehensive Error Handling

data/lib/dwh/adapters/duck_db.rb

@@ -150,7 +150,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)

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)

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

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

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)"

data/lib/dwh/settings/snowflake.yml

@@ -10,29 +10,29 @@ month_name_format: "MMMM"
 abbreviated_month_name_format: "MON"
 
 # Date functions patterns
-current_date: "current_date()"
-current_time: "current_time()"
-current_timestamp: "current_timestamp()"
+current_date: "CURRENT_DATE()"
+current_time: "CURRENT_TIME()"
+current_timestamp: "CURRENT_TIMESTAMP()"
 
-date_add: "dateadd(@unit, @val, @exp)"
-date_diff: "datediff(@unit, @start_exp, @end_exp)"
+date_add: "DATEADD(@unit, @val, @exp)"
+date_diff: "DATEDIFF(@unit, @start_exp, @end_exp)"
 date_format_sql: "TO_VARCHAR(@exp, '@format')"
 date_literal: "'@val'::DATE"
 date_time_literal: "'@val'::TIMESTAMP"
-extract_year: 'year(@exp)'
-extract_month: 'month(@exp)'
-extract_quarter: 'quarter(@exp)'
+extract_year: 'YEAR(@exp)'
+extract_month: 'MONTH(@exp)'
+extract_quarter: 'QUARTER(@exp)'
 extract_day_of_year: 'DAYOFYEAR(@exp)'
-extract_day_of_month: 'day(@exp)'
+extract_day_of_month: 'DAY(@exp)'
 extract_day_of_week: 'DAYOFWEEK(@exp)'
-extract_week_of_year: 'week(@exp)'
-extract_hour: 'hour(@exp)'
-extract_minute: 'minute(@exp)'
-extract_year_month: 'cast((TO_VARCHAR(@exp, ''YYYY'') || TO_VARCHAR(@exp, ''MM'')) as integer)'
+extract_week_of_year: 'WEEK(@exp)'
+extract_hour: 'HOUR(@exp)'
+extract_minute: 'MINUTE(@exp)'
+extract_year_month: 'CAST((TO_VARCHAR(@exp, ''YYYY'') || TO_VARCHAR(@exp, ''MM'')) as integer)'
 default_week_start_day: "monday"
 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)))"
+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)))"
 
 # array operations
 array_in_list: "ARRAY_CONTAINS(@exp, ARRAY_CONSTRUCT(@list))"

data/lib/dwh/settings/sqlite.yml

@@ -0,0 +1,42 @@
+
+
+# Date Literal Formats
+day_name_format: "%A"
+abbreviated_day_name_format: "%a"
+month_name_format: "%B"
+abbreviated_month_name_format: "%b"
+
+# Date functions patterns
+# SQLite uses strftime for most date operations
+date_add: "datetime(@exp, '+@val @unit')"
+date_diff: "CAST((julianday(@end_exp) - julianday(@start_exp)) AS INTEGER)"
+date_format_sql: "strftime('@format', @exp)"
+extract_year: "CAST(strftime('%Y', @exp) AS INTEGER)"
+extract_month: "CAST(strftime('%m', @exp) AS INTEGER)"
+extract_quarter: "CAST(((strftime('%m', @exp) - 1) / 3) + 1 AS INTEGER)"
+extract_day_of_year: "CAST(strftime('%j', @exp) AS INTEGER)"
+extract_day_of_month: "CAST(strftime('%d', @exp) AS INTEGER)"
+extract_day_of_week: "CAST(strftime('%w', @exp) AS INTEGER)"
+extract_week_of_year: "CAST(strftime('%W', @exp) AS INTEGER)"
+extract_hour: "CAST(strftime('%H', @exp) AS INTEGER)"
+extract_minute: "CAST(strftime('%M', @exp) AS INTEGER)"
+extract_year_month: "CAST(strftime('%Y%m', @exp) AS INTEGER)"
+default_week_start_day: "monday"
+week_start_day: "monday"
+sunday_week_start_day: "date(@exp, '-' || strftime('%w', @exp) || ' days')"
+monday_week_start_day: "date(@exp, '-' || ((CAST(strftime('%w', @exp) AS INTEGER) + 6) % 7) || ' days')"
+
+cast: "CAST(@exp AS @type)"
+
+# string functions
+trim: "TRIM(@exp)"
+lower_case: "LOWER(@exp)"
+upper_case: "UPPER(@exp)"
+
+# Relevant db capabilities for query gen
+create_temp_table_template: "CREATE TEMP TABLE @table AS \n@sql"
+
+# array operations - SQLite has limited native array support
+# These would need JSON extension or custom implementation
+# array_in_list: "EXISTS(SELECT 1 FROM json_each(@exp) WHERE value IN @list)"
+# array_exclude_list: "NOT EXISTS(SELECT 1 FROM json_each(@exp) WHERE value IN @list)"

data/lib/dwh/settings.rb

@@ -44,7 +44,11 @@ module DWH
         logger.debug "#{adapter_name} Adapter didn't have a settings YAML file. Using only base settings."
       end
 
-      @adapter_settings.symbolize_keys!
+      @adapter_settings.transform_keys! do |key|
+        key.to_sym
+      rescue StandardError
+        key
+      end
     end
 
     # By default settings_file are expected to be in a
@@ -69,7 +73,7 @@ module DWH
     end
 
     def adapter_name
-      name.demodulize.downcase
+      name.split('::').last.downcase
     end
 
     def using_base_settings?

data/lib/dwh/table.rb

@@ -22,16 +22,16 @@ module DWH
 
       @physical_name = parts.last
       @table_stats = table_stats
-      @catalog = catalog
-      @schema = schema
+      @catalog = catalog&.strip
+      @schema = schema&.strip
 
-      @catalog = parts.first if @catalog.nil? && parts.length > 2
+      @catalog = parts.first.strip if @catalog.nil? && parts.length > 2
 
       if @schema.nil?
         if parts.length == 2
-          @schema = parts.first
+          @schema = parts.first.strip
         elsif parts.length > 2
-          @schema = parts[1]
+          @schema = parts[1].strip
         end
       end
 
@@ -50,12 +50,20 @@ module DWH
       [catalog, schema].compact.join('.')
     end
 
+    def catalog?
+      catalog && !catalog.empty?
+    end
+
+    def schema?
+      schema && !schema.empty?
+    end
+
     def catalog_and_schema?
-      catalog && schema
+      catalog? && schema?
     end
 
     def catalog_or_schema?
-      catalog || schema
+      catalog? || schema?
     end
 
     def stats
@@ -82,13 +90,13 @@ module DWH
 
     def self.from_hash_or_json(physical_name, metadata)
       metadata = JSON.parse(metadata) if metadata.is_a?(String)
-      metadata.symbolize_keys!
+      metadata.transform_keys!(&:to_sym)
 
-      stats = TableStats.new(**metadata[:stats].symbolize_keys) if metadata.key?(:stats)
+      stats = TableStats.new(**metadata[:stats]&.transform_keys!(&:to_sym)) if metadata.key?(:stats)
       table = new(physical_name, table_stats: stats)
 
       metadata[:columns]&.each do |col|
-        col.symbolize_keys!
+        col.transform_keys!(&:to_sym)
         table << Column.new(
           name: col[:name],
           data_type: col[:data_type],

data/lib/dwh/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module DWH
-  VERSION = '0.1.1'
+  VERSION = '0.2.0'
 end

data/lib/dwh.rb

@@ -1,8 +1,4 @@
 require 'faraday'
-require 'active_support/core_ext/string/inflections'
-require 'active_support/core_ext/hash/keys'
-require 'active_support/core_ext/object/blank'
-require 'active_support/duration'
 
 require_relative 'dwh/version'
 require_relative 'dwh/errors'
@@ -19,7 +15,9 @@ require_relative 'dwh/adapters/snowflake'
 require_relative 'dwh/adapters/my_sql'
 require_relative 'dwh/adapters/sql_server'
 require_relative 'dwh/adapters/duck_db'
+require_relative 'dwh/adapters/sqlite'
 require_relative 'dwh/adapters/athena'
+require_relative 'dwh/adapters/redshift'
 
 # DWH encapsulates the full functionality of this gem.
 #
@@ -48,7 +46,9 @@ module DWH
   register(:mysql, Adapters::MySql)
   register(:sqlserver, Adapters::SqlServer)
   register(:duckdb, Adapters::DuckDb)
+  register(:sqlite, Adapters::Sqlite)
   register(:athena, Adapters::Athena)
+  register(:redshift, Adapters::Redshift)
 
   # start_reaper
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dwh
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Ajo Abraham
@@ -9,20 +9,6 @@ bindir: exe
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: activesupport
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 8.0.2
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 8.0.2
 - !ruby/object:Gem::Dependency
   name: connection_pool
   requirement: !ruby/object:Gem::Requirement
@@ -173,8 +159,10 @@ files:
 - lib/dwh/adapters/my_sql.rb
 - lib/dwh/adapters/open_authorizable.rb
 - lib/dwh/adapters/postgres.rb
+- lib/dwh/adapters/redshift.rb
 - lib/dwh/adapters/snowflake.rb
 - lib/dwh/adapters/sql_server.rb
+- lib/dwh/adapters/sqlite.rb
 - lib/dwh/adapters/trino.rb
 - lib/dwh/behaviors.rb
 - lib/dwh/capabilities.rb
@@ -197,6 +185,7 @@ files:
 - lib/dwh/settings/postgres.yml
 - lib/dwh/settings/redshift.yml
 - lib/dwh/settings/snowflake.yml
+- lib/dwh/settings/sqlite.yml
 - lib/dwh/settings/sqlserver.yml
 - lib/dwh/settings/trino.yml
 - lib/dwh/streaming_stats.rb
@@ -225,7 +214,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.7.1
+rubygems_version: 3.6.9
 specification_version: 4
 summary: Data warehouse adapters for interacting with popular data warehouses.
 test_files: []