115 lines
3.3 KiB
Ruby
115 lines
3.3 KiB
Ruby
require_relative 'parser'
|
|
|
|
class TextToSqlQuery
|
|
def initialize(text, fields, default_fields, fields_mappings = {}, joins = [])
|
|
@text = text.to_s.strip
|
|
@fields = fields.map(&:to_sym)
|
|
|
|
# Keep compatibility with previous version where default_field(s) was string/symbol
|
|
@default_fields = if default_fields.is_a? Array
|
|
default_fields.map(&:to_sym)
|
|
else
|
|
[default_fields.to_sym]
|
|
end
|
|
|
|
@fields_mappings = fields_mappings.merge(@fields.reduce({}) do |mappings, field|
|
|
_table_name, field_name = field.to_s.split('.')
|
|
mappings[field_name.to_sym] = field
|
|
mappings
|
|
end)
|
|
fields_mappings.each do |field, value|
|
|
@fields_mappings[field] = value if @fields_mappings[field]
|
|
end
|
|
@joins = joins
|
|
end
|
|
|
|
def where_clause
|
|
@parser = Query.new
|
|
@parsed_tree = @parser.parse(@text)
|
|
generate_sql @parsed_tree
|
|
end
|
|
|
|
def join_clause
|
|
return nil if @joins.empty?
|
|
return *@joins
|
|
end
|
|
|
|
private
|
|
|
|
def generate_sql(tree)
|
|
first_key = tree.keys.first
|
|
node_value = tree[first_key]
|
|
case first_key
|
|
when :DEFAULT_COLUMN
|
|
escaped_node_value = handle_special_chars node_value
|
|
query_part = '('
|
|
params_part = []
|
|
@default_fields.each do |default_field|
|
|
query_part += "CAST(#{default_field.to_s} AS TEXT) ILIKE ? OR "
|
|
params_part << "%#{escaped_node_value}%"
|
|
end
|
|
query_part = query_part[0...-4] + ')'
|
|
[query_part, *params_part]
|
|
when :OPERATOR_OR
|
|
generate_expression_for_logical_operator(:OR, node_value)
|
|
when :OPERATOR_AND
|
|
generate_expression_for_logical_operator(:AND, node_value)
|
|
when :OPERATOR_NOT
|
|
not_array = generate_sql node_value
|
|
|
|
if not_array.length < 2
|
|
raise "There should be more than 1 element for expression following NOT operator"
|
|
end
|
|
|
|
not_expression = not_array.shift
|
|
not_params = not_array
|
|
|
|
["NOT #{not_expression}"] + not_params
|
|
|
|
else
|
|
# key is column name
|
|
escaped_node_value = handle_special_chars node_value
|
|
mapping = @fields_mappings[first_key.to_sym]
|
|
if mapping.nil?
|
|
raise "Unknown field '#{first_key.to_s}'"
|
|
else
|
|
["STRING_AGG(CAST(#{mapping.to_s} AS TEXT), '') ILIKE ?", "%#{escaped_node_value}%"]
|
|
end
|
|
end
|
|
end
|
|
|
|
def generate_expression_for_logical_operator(operator, operator_array)
|
|
if operator_array.length != 2
|
|
raise "There should be two array elements for #{operator.to_s} operator"
|
|
end
|
|
|
|
first_operand = generate_sql operator_array.first
|
|
second_operand = generate_sql operator_array.last
|
|
|
|
if first_operand.length < 2
|
|
raise 'There should be more than 1 element in first operand array'
|
|
end
|
|
|
|
if second_operand.length < 2
|
|
raise 'There should be more than 1 element in second operand array'
|
|
end
|
|
|
|
first_operand_expression = first_operand.shift
|
|
first_operand_params = first_operand
|
|
|
|
second_operand_expression = second_operand.shift
|
|
second_operand_params = second_operand
|
|
|
|
["(#{first_operand_expression} #{operator.to_s} #{second_operand_expression})"] + first_operand_params + second_operand_params
|
|
end
|
|
|
|
def handle_special_chars(text)
|
|
result = text.gsub(/\"/, '')
|
|
result.gsub!(/\_/, '\_')
|
|
result.tr!('\\', '\\')
|
|
result.gsub!(/%/, '\%')
|
|
result.downcase!
|
|
result
|
|
end
|
|
end
|