quill-sql 0.1.0

data/lib/db/cached_connection.rb

@@ -0,0 +1,60 @@
+require 'redis'
+require 'json'
+require_relative 'db_helper'
+
+class CachedConnection
+  DEFAULT_CACHE_TTL = 24 * 60 * 60 # 24 hours in seconds
+
+  attr_reader :database_type, :pool, :ttl, :cache
+  attr_reader :closed
+  attr_writer :tenant_ids
+
+  def initialize(database_type, config, cache_config = {})
+    @database_type = database_type
+    @pool = DatabaseHelper.connect_to_database(database_type, config)
+    @tenant_ids = nil
+    @ttl = cache_config[:ttl] || DEFAULT_CACHE_TTL
+    @cache = get_cache(cache_config)
+    @closed = false
+  end
+
+  def query(text)
+    raise "Connection is closed" if @closed
+
+    if @cache.nil?
+      return DatabaseHelper.run_query_by_database(@database_type, @pool, text)
+    end
+
+    key = "#{@tenant_ids}:#{text}"
+    cached_result = @cache.get(key)
+
+    if cached_result
+      JSON.parse(cached_result)
+    else
+      new_result = DatabaseHelper.run_query_by_database(@database_type, @pool, text)
+      new_result_string = JSON.generate(new_result)
+      @cache.set(key, new_result_string, "EX", DEFAULT_CACHE_TTL)
+      new_result
+    end
+  rescue StandardError => e
+    raise StandardError, e.message
+  end
+
+  def get_pool
+    @pool
+  end
+
+  def close
+    DatabaseHelper.disconnect_from_database(@database_type, @pool)
+    @closed = true
+  end
+
+  private
+
+  def get_cache(config)
+    return nil unless config[:cacheType]&.match?(/^redis(s)?$/)
+
+    redis_url = "#{config[:cacheType]}://#{config[:username]}:#{config[:password]}@#{config[:host]}:#{config[:port]}"
+    Redis.new(url: redis_url)
+  end
+end

data/lib/db/clickhouse.rb

@@ -0,0 +1,333 @@
+require 'uri'
+require 'json'
+require 'click_house'
+
+module ClickHouseHelper
+  # Constants
+  CLICKHOUSE_PG_TYPE_MAP = {
+    # Signed Integer Types and Aliases
+    'Int8' => 21,
+    'TINYINT' => 21,
+    'INT1' => 21,
+    'BYTE' => 21,
+    'TINYINT SIGNED' => 21,
+    'INT1 SIGNED' => 21,
+    'Int16' => 21,
+    'SMALLINT' => 21,
+    'SMALLINT SIGNED' => 21,
+    'Int32' => 23,
+    'INT' => 23,
+    'INTEGER' => 23,
+    'MEDIUMINT' => 23,
+    'MEDIUMINT SIGNED' => 23,
+    'INT SIGNED' => 23,
+    'INTEGER SIGNED' => 23,
+    'Int64' => 20,
+    'BIGINT' => 20,
+    'SIGNED' => 20,
+    'BIGINT SIGNED' => 20,
+    'TIME' => 20,
+    # Unsigned Integer Types and Aliases
+    'UInt8' => 21,
+    'TINYINT UNSIGNED' => 21,
+    'INT1 UNSIGNED' => 21,
+    'UInt16' => 21,
+    'SMALLINT UNSIGNED' => 21,
+    'UInt32' => 23,
+    'MEDIUMINT UNSIGNED' => 23,
+    'INT UNSIGNED' => 23,
+    'INTEGER UNSIGNED' => 23,
+    'UInt64' => 20,
+    'UNSIGNED' => 20,
+    'BIGINT UNSIGNED' => 20,
+    'BIT' => 20,
+    'SET' => 20,
+    # Floating Point Types and Aliases
+    'Float32' => 700,
+    'FLOAT' => 700,
+    'REAL' => 700,
+    'SINGLE' => 700,
+    'Float64' => 701,
+    'DOUBLE' => 701,
+    'DOUBLE PRECISION' => 701,
+    'BFloat16' => 700,
+    # Decimal Types
+    'Decimal' => 1700,
+    'Decimal32' => 1700,
+    'Decimal64' => 1700,
+    'Decimal128' => 1700,
+    'Decimal256' => 1700,
+    # Boolean Type
+    'Bool' => 16,
+    # String Types and Aliases
+    'String' => 25,
+    'LONGTEXT' => 25,
+    'MEDIUMTEXT' => 25,
+    'TINYTEXT' => 25,
+    'TEXT' => 25,
+    'LONGBLOB' => 17,
+    'MEDIUMBLOB' => 17,
+    'TINYBLOB' => 17,
+    'BLOB' => 17,
+    'VARCHAR' => 1043,
+    'CHAR' => 1042,
+    'CHAR LARGE OBJECT' => 25,
+    'CHAR VARYING' => 1043,
+    'CHARACTER LARGE OBJECT' => 25,
+    'CHARACTER VARYING' => 1043,
+    'NCHAR LARGE OBJECT' => 25,
+    'NCHAR VARYING' => 1043,
+    'NATIONAL CHARACTER LARGE OBJECT' => 25,
+    'NATIONAL CHARACTER VARYING' => 1043,
+    'NATIONAL CHAR VARYING' => 1043,
+    'NATIONAL CHARACTER' => 1042,
+    'NATIONAL CHAR' => 1042,
+    'BINARY LARGE OBJECT' => 17,
+    'BINARY VARYING' => 17,
+    # Fixed String
+    'FixedString' => 1042,
+    # Identifier Types
+    'UUID' => 2950,
+    # Date and Time Types
+    'Date' => 1082,
+    'Date32' => 1082,
+    'DateTime' => 1184,
+    'DateTime64' => 1184,
+    # Array Types
+    'Array' => 2277,
+    # JSON-like Types
+    'JSON' => 3802,
+    'Nested' => 3802,
+    # Binary Types
+    'IPv4' => 17,
+    'IPv6' => 17,
+    # Enum Types
+    'Enum8' => 10045,
+    'Enum16' => 10045,
+    # Geospatial-like Types
+    'Point' => 17,
+    'Ring' => 17,
+    'Polygon' => 17,
+    # Specialized Types
+    'Nothing' => 17,
+    'Interval' => 1186
+  }.freeze
+
+  class << self
+    def parse_clickhouse_type(type)
+      # Remove whitespace and handle common variations
+      normalized_type = type.strip.gsub(/\s+/, ' ')
+
+      # Handle Object types
+      return CLICKHOUSE_PG_TYPE_MAP['JSON'] if normalized_type.start_with?('Map(')
+      return CLICKHOUSE_PG_TYPE_MAP['JSON'] if normalized_type.start_with?('AggregateFunction(')
+      return CLICKHOUSE_PG_TYPE_MAP['JSON'] if normalized_type.start_with?('SimpleAggregateFunction(')
+
+      # Handle Nullable types
+      if normalized_type.start_with?('Nullable(')
+        inner_type = normalized_type[9..-2]
+        return parse_clickhouse_type(inner_type)
+      end
+
+      # Handle Array types
+      return CLICKHOUSE_PG_TYPE_MAP['Array'] if normalized_type.start_with?('Array(')
+      return CLICKHOUSE_PG_TYPE_MAP['Array'] if normalized_type.start_with?('Tuple(')
+
+      # Handle Enum types
+      return CLICKHOUSE_PG_TYPE_MAP['Enum8'] if normalized_type.start_with?('Enum8(')
+      return CLICKHOUSE_PG_TYPE_MAP['Enum16'] if normalized_type.start_with?('Enum16(')
+
+      # Handle Decimal types
+      if normalized_type.match?(/^Decimal(\d*)?\(/)
+        return CLICKHOUSE_PG_TYPE_MAP['Decimal']
+      end
+
+      # Handle DateTime types
+      return CLICKHOUSE_PG_TYPE_MAP['DateTime'] if normalized_type.start_with?('DateTime(')
+      return CLICKHOUSE_PG_TYPE_MAP['DateTime64'] if normalized_type.start_with?('DateTime64(')
+
+      # Handle FixedString
+      return CLICKHOUSE_PG_TYPE_MAP['FixedString'] if normalized_type.start_with?('FixedString(')
+
+      # Handle LowCardinality
+      if normalized_type.start_with?('LowCardinality(')
+        inner_type = normalized_type[15..-2]
+        return parse_clickhouse_type(inner_type)
+      end
+
+      # Direct lookup (case-insensitive)
+      lookup_type = CLICKHOUSE_PG_TYPE_MAP.keys.find { |key| key.downcase == normalized_type.downcase }
+      return CLICKHOUSE_PG_TYPE_MAP[lookup_type] if lookup_type
+
+      warn "Unknown ClickHouse type: #{type}. Defaulting to VARCHAR."
+      1043 # Default to Varchar
+    end
+
+    def connect_to_clickhouse(config)
+      # Configure ClickHouse connection with provided config
+      ClickHouse.config do |config_object|
+        config_object.url = config[:url]
+        config_object.username = config[:username]
+        config_object.password = config[:password]
+      end
+    
+      # Return the connection object
+      ClickHouse.connection
+    end
+
+    def disconnect_from_clickhouse(client)
+      client.close if client.respond_to?(:close)
+    end
+
+    def run_query_clickhouse(sql, client)
+      # Need to include FORMAT JSON at the end of query to include clickhouse metadata
+      # Remove existing FORMAT from query, remove ending semicolon, and add FORMAT JSON
+      response = response = client.execute(sql.gsub(/\s*FORMAT\s+\w+/i, '').gsub(/;\s*$/, '') + ' FORMAT JSON')
+    
+      data = response.body
+  
+      fields = data['meta']&.map do |field|
+        {
+          name: field['name'],
+          dataTypeID: parse_clickhouse_type(field['type'])
+        }
+      end || []
+    
+      {
+        fields: fields,
+        rows: data['data']
+      }
+    end
+
+    def get_schemas_clickhouse(client)
+      sql = <<~SQL
+        SELECT DISTINCT database AS schema_name 
+        FROM system.tables 
+        WHERE LOWER(database) NOT IN ('system', 'information_schema')
+      SQL
+      
+      results = run_query_clickhouse(sql, client)
+      results[:rows].map { |row| row['schema_name'] }
+    end
+
+    def get_tables_by_schema_clickhouse(client, schema_names)
+      all_tables = schema_names.flat_map do |schema|
+        sql = <<~SQL
+          SELECT name as table_name, database as table_schema 
+          FROM system.tables 
+          WHERE database = '#{schema}'
+        SQL
+        
+        results = run_query_clickhouse(sql, client)
+        results[:rows].map do |row|
+          {
+            tableName: row['table_name'],
+            schemaName: row['table_schema']
+          }
+        end
+      end
+
+      all_tables
+    end
+
+    def get_columns_by_table_clickhouse(client, schema_name, table_name)
+      sql = <<~SQL
+        SELECT name as column_name 
+        FROM system.columns 
+        WHERE database = '#{schema_name}' AND table = '#{table_name}'
+      SQL
+      
+      results = run_query_clickhouse(sql, client)
+      results[:rows].map { |row| row['column_name'] }
+    end
+
+    def get_foreign_keys_clickhouse(client, schema_name, table_name, primary_key)
+      depluralized_table_name = depluralize(table_name)
+      
+      sql = <<~SQL
+        SELECT column_name 
+        FROM information_schema.columns 
+        WHERE table_schema = '#{schema_name}' 
+        AND table_name != '#{table_name}' 
+        AND (column_name = '#{primary_key}' 
+          OR column_name = '#{depluralized_table_name}_#{primary_key}' 
+          OR column_name = '#{depluralized_table_name}#{capitalize(primary_key)}')
+      SQL
+
+      results = run_query_clickhouse(sql, client)
+      foreign_keys = results[:rows].map { |key| key['column_name'] }
+      
+      foreign_keys = foreign_keys.reject { |key| ['id', '_id_'].include?(key) }
+      foreign_keys = foreign_keys.uniq
+
+      if foreign_keys.empty?
+        sql = <<~SQL
+          SELECT column_name 
+          FROM information_schema.columns 
+          WHERE table_schema = '#{schema_name}' 
+          AND table_name != '#{table_name}' 
+          AND (column_name LIKE '#{table_name}%' 
+            OR column_name LIKE '%\_id' 
+            OR column_name LIKE '%Id' 
+            OR column_name LIKE '%\_#{primary_key}' 
+            OR column_name LIKE '%#{capitalize(primary_key)}')
+        SQL
+
+        results = run_query_clickhouse(sql, client)
+        foreign_keys = results[:rows].map { |key| key['column_name'] }.uniq
+      end
+
+      foreign_keys
+    end
+
+    def get_schema_column_info_clickhouse(client, schema_name, table_names)
+      table_names.map do |table_name|
+        query = <<~SQL
+          SELECT 
+            name as "column_name",
+            type as "field_type"
+          FROM system.columns
+          WHERE database = '#{table_name[:schemaName]}'
+          AND table = '#{table_name[:tableName]}'
+        SQL
+
+        results = run_query_clickhouse(query, client)
+        {
+          tableName: "#{table_name[:schemaName]}.#{table_name[:tableName]}",
+          displayName: "#{table_name[:schemaName]}.#{table_name[:tableName]}",
+          columns: results[:rows].map do |row|
+            type_oid = parse_clickhouse_type(row['field_type'])
+            {
+              columnName: row['column_name'],
+              displayName: row['column_name'],
+              dataTypeID: type_oid,
+              fieldType: row['field_type']
+            }
+          end
+        }
+      end
+    end
+
+    def format_clickhouse_config(connection_string)
+      parsed = URI.parse(connection_string)
+      
+      {
+        url: "#{parsed.scheme}://#{parsed.host}:#{parsed.port}",
+        username: parsed.user || 'default',
+        password: parsed.password || ''
+      }
+    end
+
+    private
+
+    def capitalize(str)
+      str.capitalize
+    end
+
+    def depluralize(str)
+      # Simple depluralization - you might want to use a proper library like ActiveSupport
+      return str[0..-2] if str.end_with?('s')
+      str
+    end
+  end
+end

data/lib/db/db_helper.rb

@@ -0,0 +1,115 @@
+require 'json'
+require 'uri'
+require_relative 'clickhouse'
+
+module DatabaseHelper
+  SUPPORTED_DATABASES = ['clickhouse'].freeze  # Add others as they're implemented
+
+  class QuillQueryResults
+    attr_reader :fields, :rows
+
+    def initialize(fields, rows)
+      @fields = fields
+      @rows = rows
+    end
+  end
+
+  class DatabaseError < StandardError; end
+
+  def self.get_database_credentials(database_type, connection_string)
+    case database_type.downcase
+    when 'clickhouse'
+      ClickHouseHelper.format_clickhouse_config(connection_string)
+    else
+      raise DatabaseError, "Invalid database type: #{database_type}"
+    end
+  end
+
+  def self.connect_to_database(database_type, config)
+    case database_type.downcase
+    when 'clickhouse'
+      ClickHouseHelper.connect_to_clickhouse(config)
+    else
+      raise DatabaseError, "Invalid database type: #{database_type}"
+    end
+  end
+
+  def self.with_connection(database_type, connection_string)
+    config = get_database_credentials(database_type, connection_string)
+    connection = connect_to_database(database_type, config)
+    begin
+      yield(connection)
+    rescue StandardError => e
+      { success: false, message: e.message || e.error || e.to_s }
+    ensure
+      disconnect_from_database(database_type, connection)
+    end
+  end
+
+  def self.run_query_by_database(database_type, connection, sql)
+    case database_type.downcase
+    when 'clickhouse'
+      ClickHouseHelper.run_query_clickhouse(sql, connection)
+    else
+      raise DatabaseError, "Invalid database type: #{database_type}"
+    end
+  end
+
+  def self.connect_and_run_query(database_type, connection_string, sql)
+    with_connection(database_type, connection_string) do |connection|
+      run_query_by_database(database_type, connection, sql)
+    end
+  end
+
+  def self.disconnect_from_database(database_type, database)
+    case database_type.downcase
+    when 'clickhouse'
+      ClickHouseHelper.disconnect_from_clickhouse(database)
+    end
+  end
+
+  def self.get_schemas_by_database(database_type, connection)
+    case database_type.downcase
+    when 'clickhouse'
+      ClickHouseHelper.get_schemas_clickhouse(connection)
+    else
+      raise DatabaseError, "Invalid database type: #{database_type}"
+    end
+  end
+
+  def self.get_tables_by_schema_by_database(database_type, connection, schema_name)
+    case database_type.downcase
+    when 'clickhouse'
+      ClickHouseHelper.get_tables_by_schema_clickhouse(connection, schema_name)
+    else
+      raise DatabaseError, "Invalid database type: #{database_type}"
+    end
+  end
+
+  def self.get_columns_by_table_by_database(database_type, connection, schema_name, table_name)
+    case database_type.downcase
+    when 'clickhouse'
+      ClickHouseHelper.get_columns_by_table_clickhouse(connection, schema_name, table_name)
+    else
+      raise DatabaseError, "Invalid database type: #{database_type}"
+    end
+  end
+
+  def self.get_foreign_keys_by_database(database_type, connection, schema_name, table_name, primary_key)
+    case database_type.downcase
+    when 'clickhouse'
+      ClickHouseHelper.get_foreign_keys_clickhouse(connection, schema_name, table_name, primary_key)
+    else
+      raise DatabaseError, "Invalid database type: #{database_type}"
+    end
+  end
+
+  def self.get_column_info_by_schema_by_database(database_type, connection, schema_name, tables)
+    case database_type.downcase
+    when 'clickhouse'
+      ClickHouseHelper.get_schema_column_info_clickhouse(connection, schema_name, tables)
+    else
+      raise DatabaseError, "Invalid database type: #{database_type}"
+    end
+  end
+end

data/lib/models/filters.rb

@@ -0,0 +1,142 @@
+module StringOperator
+  IS_EXACTLY = 'is exactly'
+  IS_NOT_EXACTLY = 'is not exactly'
+  CONTAINS = 'contains'
+  IS = 'is'
+  IS_NOT = 'is not'
+end
+
+module DateOperator
+  CUSTOM = 'custom'
+  IN_THE_LAST = 'in the last'
+  IN_THE_PREVIOUS = 'in the previous'
+  IN_THE_CURRENT = 'in the current'
+  EQUAL_TO = 'equal to'
+  NOT_EQUAL_TO = 'not equal to'
+  GREATER_THAN = 'greater than'
+  LESS_THAN = 'less than'
+  GREATER_THAN_OR_EQUAL_TO = 'greater than or equal to'
+  LESS_THAN_OR_EQUAL_TO = 'less than or equal to'
+end
+
+module NumberOperator
+  EQUAL_TO = 'equal to'
+  NOT_EQUAL_TO = 'not equal to'
+  GREATER_THAN = 'greater than'
+  LESS_THAN = 'less than'
+  GREATER_THAN_OR_EQUAL_TO = 'greater than or equal to'
+  LESS_THAN_OR_EQUAL_TO = 'less than or equal to'
+end
+
+module NullOperator
+  IS_NOT_NULL = 'is not null'
+  IS_NULL = 'is null'
+end
+
+module BoolOperator
+  EQUAL_TO = 'equal to'
+  NOT_EQUAL_TO = 'not equal to'
+end
+
+module TimeUnit
+  YEAR = 'year'
+  QUARTER = 'quarter'
+  MONTH = 'month'
+  WEEK = 'week'
+  DAY = 'day'
+  HOUR = 'hour'
+end
+
+module FieldType
+  STRING = 'string'
+  NUMBER = 'number'
+  DATE = 'date'
+  NULL = 'null'
+  BOOLEAN = 'boolean'
+end
+
+module FilterType
+  STRING_FILTER = 'string-filter'
+  DATE_FILTER = 'date-filter'
+  DATE_CUSTOM_FILTER = 'date-custom-filter'
+  DATE_COMPARISON_FILTER = 'date-comparison-filter'
+  NUMERIC_FILTER = 'numeric-filter'
+  NULL_FILTER = 'null-filter'
+  STRING_IN_FILTER = 'string-in-filter'
+  BOOLEAN_FILTER = 'boolean-filter'
+end
+
+module FilterUtils
+  def convert_custom_filter(filter)
+    case filter[:filter_type]
+    when FilterType::STRING_FILTER
+      validate_string_filter(filter)
+      filter.merge(field_type: FieldType::STRING)
+    when FilterType::STRING_IN_FILTER
+      validate_string_in_filter(filter)
+      filter.merge(field_type: FieldType::STRING)
+    when FilterType::NUMERIC_FILTER
+      validate_numeric_filter(filter)
+      filter.merge(field_type: FieldType::NUMBER)
+    when FilterType::NULL_FILTER
+      validate_null_filter(filter)
+      filter.merge(field_type: FieldType::NULL)
+    when FilterType::BOOLEAN_FILTER
+      validate_boolean_filter(filter)
+      filter.merge(field_type: FieldType::BOOLEAN)
+    when FilterType::DATE_FILTER
+      validate_date_filter(filter)
+      filter.merge(field_type: FieldType::DATE)
+    when FilterType::DATE_CUSTOM_FILTER
+      validate_date_custom_filter(filter)
+      filter.merge(field_type: FieldType::DATE)
+    when FilterType::DATE_COMPARISON_FILTER
+      validate_date_comparison_filter(filter)
+      filter.merge(field_type: FieldType::DATE)
+    end
+  end
+end
+
+private
+
+def validate_string_filter(filter)
+  raise "Invalid value for StringFilter" unless filter[:value].is_a?(String)
+  raise "Invalid operator for StringFilter" unless StringOperator.constants.map { |c| StringOperator.const_get(c) }.include?(filter[:operator])
+end
+
+def validate_string_in_filter(filter)
+  raise "Invalid value for StringInFilter" unless filter[:value].is_a?(Array)
+  raise "Invalid operator for StringInFilter" unless StringOperator.constants.map { |c| StringOperator.const_get(c) }.include?(filter[:operator])
+end
+
+def validate_numeric_filter(filter)
+  raise "Invalid value for NumericFilter" unless filter[:value].is_a?(Numeric)
+  raise "Invalid operator for NumericFilter" unless NumberOperator.constants.map { |c| NumberOperator.const_get(c) }.include?(filter[:operator])
+end
+
+def validate_null_filter(filter)
+  raise "Invalid value for NullFilter" unless filter[:value].nil?
+  raise "Invalid operator for NullFilter" unless NullOperator.constants.map { |c| NullOperator.const_get(c) }.include?(filter[:operator])
+end
+
+def validate_boolean_filter(filter)
+  raise "Invalid value for BooleanFilter" unless [true, false].include?(filter[:value])
+  raise "Invalid operator for BooleanFilter" unless BoolOperator.constants.map { |c| BoolOperator.const_get(c) }.include?(filter[:operator])
+end
+
+def validate_date_filter(filter)
+  value = filter[:value]
+  raise "Invalid value for DateFilter" unless value.is_a?(Hash) && value[:value].is_a?(Numeric) && value[:unit].is_a?(String)
+  raise "Invalid operator for DateFilter" unless DateOperator.constants.map { |c| DateOperator.const_get(c) }.include?(filter[:operator])
+end
+
+def validate_date_custom_filter(filter)
+  value = filter[:value]
+  raise "Invalid value for DateCustomFilter" unless value.is_a?(Hash) && value[:start_date].is_a?(String) && value[:end_date].is_a?(String)
+  raise "Invalid operator for DateCustomFilter" unless DateOperator.constants.map { |c| DateOperator.const_get(c) }.include?(filter[:operator])
+end
+
+def validate_date_comparison_filter(filter)
+  raise "Invalid value for DateComparisonFilter" unless filter[:value].is_a?(String)
+  raise "Invalid operator for DateComparisonFilter" unless DateOperator.constants.map { |c| DateOperator.const_get(c) }.include?(filter[:operator])
+end