cdmduck 0.0.1__py3-none-any.whl

cdmduck/__init__.py

@@ -0,0 +1,2 @@
+"""cdmduck — OMOP CDM · OHDSI ATLAS 호환 도구를 DuckDB 위에서, 순수 파이썬으로."""
+__version__ = '0.0.1'

cdmduck/cli.py

@@ -0,0 +1,28 @@
+"""명령어 `cdmduck`."""
+import argparse
+import sys
+
+
+def main(argv=None):
+    ap = argparse.ArgumentParser(prog='cdmduck', description='OMOP CDM / ATLAS-compatible tools on DuckDB')
+    sub = ap.add_subparsers(dest='cmd', required=True)
+    t = sub.add_parser('translate', help='SQL Server 방언 SQL 을 대상 방언으로 번역')
+    t.add_argument('file', help="SQL 파일 ('-' 는 표준입력)")
+    t.add_argument('dialect')
+    t.add_argument('--temp-schema')
+    t.add_argument('-p', '--param', action='append', default=[], metavar='KEY=VALUE', help='번역 전에 렌더할 파라미터')
+    sub.add_parser('dialects', help='지원 방언 목록')
+    a = ap.parse_args(argv)
+    from .sqlrender import dialects, render, translate
+    if a.cmd == 'dialects':
+        print('\n'.join(dialects()))
+    elif a.cmd == 'translate':
+        sql = sys.stdin.read() if a.file == '-' else open(a.file, encoding='utf-8').read()
+        if a.param:
+            sql = render(sql, **dict(p.split('=', 1) for p in a.param))
+        sys.stdout.write(translate(sql, a.dialect, temp_emulation_schema=a.temp_schema))
+    return 0
+
+
+if __name__ == '__main__':
+    sys.exit(main())

cdmduck/sqlrender/__init__.py

@@ -0,0 +1,37 @@
+"""OHDSI SqlRender 의 파이썬 이식 — Java 판과 출력이 글자 단위로 같도록 맞춘다.
+
+    from cdmduck.sqlrender import render, translate
+    sql = render("SELECT * FROM @cdm.person {@limit}?{LIMIT 10}", cdm="main", limit=True)
+    sql = translate(sql, "duckdb")
+"""
+from ._java import JavaError
+from ._render import check as check_render
+from ._render import render_sql
+from ._strings import split_sql
+from ._translate import (check as check_translate, dialects, generate_session_id, set_replacement_patterns,
+                         translate_single_statement_sql, translate_sql)
+
+__all__ = ['render', 'translate', 'translate_single_statement', 'split_sql', 'render_sql', 'translate_sql',
+           'translate_single_statement_sql', 'dialects', 'generate_session_id', 'set_replacement_patterns',
+           'check_render', 'check_translate', 'JavaError']
+
+
+def _value(v):
+    """R SqlRender 와 같은 값 변환: 논리값은 TRUE/FALSE, 목록은 쉼표로 잇는다."""
+    if isinstance(v, bool):
+        return 'TRUE' if v else 'FALSE'
+    if isinstance(v, (list, tuple, set)):
+        return ','.join(_value(x) for x in v)
+    return str(v)
+
+
+def render(sql, **params):
+    return render_sql(sql, list(params), [_value(v) for v in params.values()])
+
+
+def translate(sql, target_dialect, temp_emulation_schema=None, session_id=None):
+    return translate_sql(sql, target_dialect, session_id, temp_emulation_schema)
+
+
+def translate_single_statement(sql, target_dialect, temp_emulation_schema=None, session_id=None):
+    return translate_single_statement_sql(sql, target_dialect, session_id, temp_emulation_schema)

cdmduck/sqlrender/_bigquery_spark.py

@@ -0,0 +1,207 @@
+"""org.ohdsi.sql.BigQuerySparkTranslate 포팅 (DB 연결이 필요한 sparkHandleInsert 는 제외)."""
+import re
+
+from ._java import JavaError, split, substring, trim
+from ._strings import split_sql, tokenize_sql
+from ._translate import parse_search_pattern, search
+
+SELECT, GROUP_BY, ORDER_BY, WITH_COLUMNS, IN = range(5)
+
+
+class _CommaListIterator:
+    def __init__(self, expression_list, list_type):
+        self.list_type = list_type
+        self.expression_list = expression_list
+        self._split_list()
+        self.expression_list = ',' + self.expression_list + ','
+        self.pattern = parse_search_pattern(', @@a ,')
+        self.cur = search(self.expression_list, self.pattern, 0)
+        if self.cur.start != -1:
+            self._split_expression()
+
+    def done(self):
+        return self.cur.start == -1
+
+    def next(self):
+        n = len(tokenize_sql(substring(self.expression_list, self.cur.start, self.cur.end)))
+        self.cur = search(self.expression_list, self.pattern, self.cur.start_token + n - 1)
+        if self.cur.start != -1:
+            self._split_expression()
+
+    def full(self):
+        return _s(self.prefix) + _s(self.suffix)
+
+    def _split_list(self):
+        self.list_prefix = ''
+        self.list_suffix = ''
+        if self.list_type == SELECT:
+            m = search('^' + _s(self.expression_list) + '$', parse_search_pattern('^ distinct @@a $'), 0)
+            if m.start != -1:
+                self.list_prefix = 'distinct '
+                self.expression_list = m.variable_to_value.get('@@a')
+            m = search('^' + _s(self.expression_list) + '$', parse_search_pattern('^@@a into @@b$'), 0)
+            if m.start != -1:
+                self.expression_list = m.variable_to_value.get('@@a')
+                self.list_suffix = ' into ' + _s(m.variable_to_value.get('@@b'))
+        elif self.list_type == GROUP_BY:
+            m = search('^' + _s(self.expression_list) + '$', parse_search_pattern('^@@a order by @@b$'), 0)
+            if m.start != -1:
+                self.expression_list = m.variable_to_value.get('@@a')
+                self.list_suffix = ' order by ' + _s(m.variable_to_value.get('@@b'))
+
+    def _split_expression(self):
+        self.prefix = self.cur.variable_to_value.get('@@a')
+        self.suffix = ''
+        if self.list_type == SELECT:
+            self._split_alias()
+        elif self.list_type == ORDER_BY:
+            tokens = tokenize_sql(self.full())
+            if not tokens:
+                raise JavaError('IndexOutOfBoundsException')
+            last = tokens[-1]
+            if last.text.lower() in ('asc', 'desc'):
+                self.prefix = substring(self.full(), 0, last.start - 1)
+                self.suffix = ' ' + last.text
+
+    def _split_alias(self):
+        tokens = tokenize_sql(self.prefix)
+        m = search('^' + self.prefix + '$', parse_search_pattern('^ @@a as @@b $'), 0)
+        if m.start == -1:
+            if len(tokens) >= 2:
+                alias = tokens[-1]
+                preceding = tokens[-2].text
+                if alias.is_identifier() and preceding != '.' and preceding != '+':
+                    self.prefix = substring(self.prefix, 0, alias.start)
+                    self.suffix = alias.text
+        else:
+            self.prefix = m.variable_to_value.get('@@a')
+            self.suffix = m.variable_to_value.get('@@b')
+
+    def is_single_column_reference(self):
+        t = tokenize_sql(self.prefix)
+        return len(t) == 3 and t[0].is_identifier() and t[1].text == '.' and t[2].is_identifier()
+
+
+def _s(x):
+    """Java 문자열 연결: null 은 "null"."""
+    return 'null' if x is None else x
+
+
+def _alias_ctes(sql, pattern):
+    pp = parse_search_pattern(pattern)
+    m = search(sql, pp, 0)
+    while m.start != -1:
+        vv = m.variable_to_value
+        with_it = _CommaListIterator(vv.get('@@b'), WITH_COLUMNS)
+        sel_it = _CommaListIterator(vv.get('@@c'), SELECT)
+        repl = ''
+        while not with_it.done():
+            if sel_it.done():
+                break
+            expr = _s(sel_it.prefix) + ' as ' + with_it.full()
+            if repl:
+                repl += ','
+            repl += expr
+            with_it.next()
+            sel_it.next()
+        repl = sel_it.list_prefix + repl + sel_it.list_suffix
+        a = vv.get('@@a')
+        if a is None:
+            raise JavaError('NullPointerException')
+        body = pattern.replace('@@a', a).replace('(@@b)', '').replace('@@c', repl).replace('@@d', vv.get('@@d') or '')
+        sql = substring(sql, 0, m.start) + body + substring(sql, m.end)
+        m = search(sql, pp, m.start_token + 1)
+    return sql
+
+
+def _convert_select_list_references(sql, select_pattern, list_type):
+    pp = parse_search_pattern(select_pattern)
+    m = search(sql, pp, 0)
+    while m.start != -1:
+        vv = m.variable_to_value
+        select_list = vv.get('@@s')
+        repl = ''
+        it = _CommaListIterator(vv.get('@@r'), list_type)
+        while not it.done():
+            expr, suffix = it.prefix, it.suffix
+            expr_pp = parse_search_pattern(expr)
+            if it.is_single_column_reference():
+                repl += ', ' + expr + suffix
+            else:
+                sel_it = _CommaListIterator(select_list, SELECT)
+                found = False
+                i = 1
+                while not sel_it.done():
+                    if search(sel_it.prefix, expr_pp, 0).start != -1:
+                        found = True
+                        repl += ', ' + str(i) + suffix
+                        break
+                    i += 1
+                    sel_it.next()
+                if not found:
+                    repl += ', ' + expr + suffix
+            it.next()
+        repl = it.list_prefix + substring(repl, 1) + it.list_suffix
+        tail = substring(sql, m.end)
+        sql = substring(sql, 0, m.start)
+        for block in pp:
+            if sql:
+                sql += ' '
+            if block.is_variable:
+                sql += repl if block.text == '@@r' else _s(vv.get(block.text))
+            else:
+                sql += block.text
+        sql += tail
+        m = search(sql, pp, m.start_token + 1)
+    return sql
+
+
+def _lower_case(sql):
+    for t in tokenize_sql(sql):
+        if not t.in_quotes and not t.text.startswith('@'):
+            sql = substring(sql, 0, t.start) + t.text.lower() + substring(sql, t.end)
+    return sql
+
+
+def translate_bigquery(sql):
+    sql = _lower_case(sql)
+    sql = _alias_ctes(sql, 'with @@a (@@b) as (select @@c from @@d)')
+    sql = _alias_ctes(sql, 'with @@a (@@b) as (select @@c union @@d)')
+    sql = _alias_ctes(sql, 'with @@a (@@b) as (select @@c)')
+    sql = _alias_ctes(sql, ', @@a (@@b) as (select @@c from @@d)')
+    g = 'select @@s from @@b group by @@r'
+    for suffix in (';', ')', ' having', ' order by'):
+        sql = _convert_select_list_references(sql, g + suffix, GROUP_BY)
+    o = 'select @@s from @@b order by @@r'
+    for suffix in (';', ')'):
+        sql = _convert_select_list_references(sql, o + suffix, ORDER_BY)
+    return sql
+
+
+def _spark_create_table(sql):
+    if not sql.endswith(';'):
+        sql += ';'
+    pp = parse_search_pattern('CREATE TABLE @@table (@@definition)')
+    sql = re.sub(' +', ' ', trim(sql).replace('\t', ' '))
+    m = search(sql, pp, 0)
+    table = m.variable_to_value.get('@@table')
+    definition = m.variable_to_value.get('@@definition')
+    if table is not None and definition is not None:
+        table = table.replace('\r\n', '')
+        definition = definition.lower().replace('\r\n', '').replace(' as ', ' ')
+        cols = []
+        for f in split(definition, ','):
+            parts = split(trim(f), ' ')
+            if len(parts) < 2:
+                raise JavaError('ArrayIndexOutOfBoundsException')
+            cols.append('\tCAST(NULL AS ' + parts[1] + ') AS ' + parts[0])
+        sql = substring(sql, 0, m.start) + 'SELECT ' + ',\r\n'.join(cols) + ' INTO ' + table + ' WHERE 1 = 0'
+    return sql.replace(';', '')
+
+
+def translate_spark(sql):
+    parts = [_spark_create_table(p) for p in split_sql(sql)]
+    joined = trim(';\r\n'.join(parts))
+    if len(parts) > 1 or trim(sql).endswith(';'):
+        return joined + ';'
+    return joined

cdmduck/sqlrender/_java.py

@@ -0,0 +1,124 @@
+"""Java 동작을 그대로 흉내 내는 보조 함수들.
+
+SqlRender(Java) 와 출력이 글자 단위로 같아야 하므로 Python 기본 동작과 다른 부분을 여기서 맞춘다:
+String.trim/split, Character.isWhitespace/isLetterOrDigit, HashMap 순회 순서, 범위를 벗어난 substring 의 예외.
+"""
+import re
+import unicodedata
+
+__all__ = ['JavaError', 'trim', 'split', 'is_whitespace', 'is_letter_or_digit', 'is_letter', 'substring',
+           'char_at', 'hash_order', 'strip_trailing_ws_once',
+           'strip_ws_before_end', 'remove_blank_lines']
+
+
+class JavaError(RuntimeError):
+    """Java 쪽이 예외(StringIndexOutOfBounds, RuntimeException 등)를 던지는 자리."""
+
+
+def trim(s):
+    """String.trim(): 앞뒤의 코드포인트 ≤ U+0020 문자를 지운다(유니코드 공백은 건드리지 않음)."""
+    i, j = 0, len(s)
+    while i < j and s[i] <= ' ':
+        i += 1
+    while j > i and s[j - 1] <= ' ':
+        j -= 1
+    return s[i:j]
+
+
+def split(s, regex):
+    """String.split(regex): 끝쪽 빈 문자열을 버리고, 일치가 전혀 없으면 [s]."""
+    parts = re.split(regex, s)
+    if len(parts) == 1:
+        return [s]
+    while parts and parts[-1] == '':
+        parts.pop()
+    return parts
+
+
+_JAVA_SPACE_EXCLUDED = {' ', ' ', ' '}
+
+
+def is_whitespace(ch):
+    """Character.isWhitespace."""
+    if ch in '\t\n\u000b\f\r\u001c\u001d\u001e\u001f':
+        return True
+    if ch in _JAVA_SPACE_EXCLUDED:
+        return False
+    return unicodedata.category(ch) in ('Zs', 'Zl', 'Zp')
+
+
+def is_letter(ch):
+    """Character.isLetter: Lu Ll Lt Lm Lo."""
+    return unicodedata.category(ch) in ('Lu', 'Ll', 'Lt', 'Lm', 'Lo')
+
+
+def is_letter_or_digit(ch):
+    """Character.isLetterOrDigit: 문자 또는 Nd(십진 숫자)."""
+    c = unicodedata.category(ch)
+    return c in ('Lu', 'Ll', 'Lt', 'Lm', 'Lo', 'Nd')
+
+
+def substring(s, start, end=None):
+    """String.substring: 범위를 벗어나면 예외."""
+    if end is None:
+        end = len(s)
+    if start < 0 or end > len(s) or start > end:
+        raise JavaError(f'StringIndexOutOfBoundsException: begin {start}, end {end}, length {len(s)}')
+    return s[start:end]
+
+
+def char_at(s, i):
+    if i < 0 or i >= len(s):
+        raise JavaError(f'StringIndexOutOfBoundsException: index {i}, length {len(s)}')
+    return s[i]
+
+
+def _string_hash(s):
+    """java.lang.String.hashCode (UTF-16 단위)."""
+    h = 0
+    data = s.encode('utf-16-be')
+    for k in range(0, len(data), 2):
+        h = (31 * h + ((data[k] << 8) | data[k + 1])) & 0xFFFFFFFF
+    return h
+
+
+def hash_order(keys):
+    """java.util.HashMap 의 순회 순서로 키를 정렬한다(삽입 순서 목록을 받는다).
+    용량은 16에서 시작해 크기가 0.75배를 넘으면 두 배. 버킷 = (h ^ h>>>16) & (cap-1), 같은 버킷은 삽입 순서."""
+    n = len(keys)
+    cap = 16
+    while n > cap * 0.75:
+        cap *= 2
+    def bucket(k):
+        h = _string_hash(k)
+        h ^= h >> 16
+        return h & (cap - 1)
+    return [k for _, _, k in sorted((bucket(k), i, k) for i, k in enumerate(keys))]
+
+
+def strip_trailing_ws_once(s):
+    """s.replaceAll("\\s$", "") — Java 의 \\s 는 [ \\t\\n\\x0B\\f\\r], $ 는 끝 또는 마지막 줄바꿈 앞."""
+    return re.sub(r'[ \t\n\x0b\f\r]$', '', s)
+
+
+_LINE_TERMS = '\n\r\u0085

'
+
+
+def strip_ws_before_end(s):
+    """s.replaceAll("\\\\s$", "") 를 Java 규칙 그대로: $ 는 입력 끝 또는 마지막 줄끝문자(\\r\\n 포함) 바로 앞."""
+    n = len(s)
+    ends = {n}
+    if s.endswith('\r\n'):
+        ends.add(n - 2)
+    elif n and s[-1] in _LINE_TERMS:
+        ends.add(n - 1)
+    drop = {p - 1 for p in ends if p > 0 and s[p - 1] in ' \t\n\x0b\f\r'}
+    return ''.join(ch for i, ch in enumerate(s) if i not in drop)
+
+
+# Java (?m)^[ \t]*\r?\n : ^ 는 처음, [\n\u0085

] 뒤, 또는 \n 이 따르지 않는 \r 뒤
+_BLANK_LINE_RE = re.compile('(?:\\A|(?<=[\n\u0085

])|(?<=\r)(?!\n))[ \t]*\r?\n')
+
+
+def remove_blank_lines(s):
+    return _BLANK_LINE_RE.sub('', s)

cdmduck/sqlrender/_render.py

@@ -0,0 +1,220 @@
+"""org.ohdsi.sql.SqlRender 포팅: @파라미터 치환, {DEFAULT …}, {조건} ? {참} : {거짓}."""
+import re
+
+from ._java import JavaError, hash_order, is_whitespace, split, substring, trim
+from ._strings import replace as _str_replace
+
+_JAVA_WS = '[ \\t\\n\\x0b\\f\\r]'
+_DEFAULTS_RE = re.compile(r'\{DEFAULT[^}]*\}' + _JAVA_WS + '*\n?')
+
+
+class _Span:
+    __slots__ = ('start', 'end', 'valid')
+
+    def __init__(self, start, end):
+        self.start, self.end, self.valid = start, end, True
+
+
+class _IfThenElse:
+    __slots__ = ('condition', 'if_true', 'if_false', 'has_if_false')
+
+    def __init__(self):
+        self.condition = self.if_true = self.if_false = None
+        self.has_if_false = False
+
+    def start(self):
+        return self.condition.start
+
+    def end(self):
+        return self.if_false.end if self.has_if_false else self.if_true.end
+
+
+def _find_spans(s, open_ch, close_ch):
+    starts, spans = [], []
+    for i, ch in enumerate(s):
+        if ch == open_ch:
+            starts.append(i)
+        elif ch == close_ch and starts:
+            spans.append(_Span(starts.pop(), i + 1))
+    return spans
+
+
+def _link_if_then_elses(s, spans):
+    # Java 와 같이 break 없이 전부 훑는다: 한 조건에 '?' 짝이 여럿이면 여럿 만들고, ':' 는 마지막 것이 이긴다
+    out = []
+    n = len(spans)
+    if n > 1:
+        for i in range(n - 1):
+            for j in range(i + 1, n):
+                if spans[j].start > spans[i].end:
+                    if trim(s[spans[i].end:spans[j].start]) == '?':
+                        ite = _IfThenElse()
+                        ite.condition = spans[i]
+                        ite.if_true = spans[j]
+                        for k in range(j + 1, n):
+                            if spans[k].start > spans[j].end:
+                                if trim(s[spans[j].end:spans[k].start]) == ':':
+                                    ite.if_false = spans[k]
+                                    ite.has_if_false = True
+                        out.append(ite)
+    return out
+
+
+def _remove_parentheses(s):
+    if len(s) > 1 and ((s[0] == "'" and s[-1] == "'") or (s[0] == '"' and s[-1] == '"')):
+        return s[1:-1]
+    return s
+
+
+def _preceded_by_in(start, s):
+    s = s.lower()
+    matched = 0
+    for i in range(start - 1, -1, -1):
+        ch = s[i]
+        if not is_whitespace(ch):
+            if matched == 0 and ch == 'n':
+                matched += 1
+            elif matched == 1 and ch == 'i':
+                matched += 1
+            else:
+                return False
+        elif matched == 2:
+            return True
+    return False
+
+
+def _evaluate_primitive(s):
+    s = trim(s)
+    lc = s.lower()
+    if lc in ('false', '0', '!true', '!1'):
+        return False
+    if lc in ('true', '1', '!false', '!0'):
+        return True
+    found = s.find('==')
+    if found != -1:
+        left = _remove_parentheses(trim(s[:found]))
+        right = _remove_parentheses(trim(s[found + 2:]))
+        return left == right
+    found = s.find('!=')
+    if found == -1:
+        found = s.find('<>')
+    if found != -1:
+        left = _remove_parentheses(trim(s[:found]))
+        right = _remove_parentheses(trim(s[found + 2:]))
+        return left != right
+    found = lc.find(' in ')
+    if found != -1:
+        left = _remove_parentheses(trim(substring(s, 0, found)))
+        right = trim(substring(s, found + 4))
+        if len(right) > 2 and right[0] == '(' and right[-1] == ')':
+            for part in split(right[1:-1], ','):
+                if left == _remove_parentheses(part):     # Java 도 part 를 trim 하지 않는다
+                    return True
+            return False
+    raise JavaError('Error parsing boolean condition: "' + s + '"')
+
+
+def _evaluate_boolean(s):
+    s = trim(s)
+    if '&' in s:
+        return all(_evaluate_primitive(p) for p in split(s, '&'))
+    if '|' in s:
+        return any(_evaluate_primitive(p) for p in split(s, r'\|'))
+    return _evaluate_primitive(s)
+
+
+def _replace(s, spans, to_start, to_end, with_start, with_end):
+    with_str = substring(s, with_start, with_end + 1)
+    s = _str_replace(s, to_start, to_end, with_str)
+    for sp in spans:
+        if sp.valid:
+            if sp.start > to_start:
+                if with_start <= sp.start < with_end:
+                    delta = to_start - with_start
+                    sp.start += delta
+                    sp.end += delta
+                elif sp.start > to_end:
+                    delta = to_start - to_end + len(with_str)
+                    sp.start += delta
+                    sp.end += delta
+                else:
+                    sp.valid = False
+            elif sp.end > to_end:
+                sp.end += to_start - to_end + len(with_str)
+    return s
+
+
+def _evaluate_condition(s):
+    s = trim(s)
+    spans = _find_spans(s, '(', ')')
+    # 닫는 괄호 순서라 안쪽 괄호가 먼저 처리된다. Java 도 여기서는 valid 를 보지 않는다
+    for sp in spans:
+        if not _preceded_by_in(sp.start, s):
+            ev = _evaluate_boolean(substring(s, sp.start + 1, sp.end - 1))
+            s = substring(s, 0, sp.start) + ('1' if ev else '0') + substring(s, sp.start + 1)
+            s = _replace(s, spans, sp.start, sp.end, sp.start, sp.start)
+    return _evaluate_boolean(s)
+
+
+def _extract_defaults(s):
+    defaults = {}
+    pre, post = '{DEFAULT ', '}'
+    d_start = d_end = 0
+    while d_start != -1 and d_end != -1:
+        d_start = s.find(pre, d_end)
+        if d_start != -1:
+            d_end = s.find(post, d_start + len(pre))
+            if d_end != -1:
+                span = s[d_start + len(pre):d_end]
+                found = span.find('=')
+                if found != -1:
+                    param = trim(span[:found])
+                    if param and param[0] == '@':
+                        param = param[1:]
+                    defaults[param] = _remove_parentheses(trim(substring(span, found + 2)))
+    return defaults
+
+
+def _substitute_parameters(s, params):
+    """params: 삽입 순서를 지닌 dict (Java HashMap 에 넣은 순서)."""
+    defaults = _extract_defaults(s)
+    s = _DEFAULTS_RE.sub('', s)
+    params = dict(params)
+    for k in hash_order(list(defaults)):
+        if k not in params:
+            params[k] = defaults[k]
+    # HashMap 순회 순서에서 키 길이 내림차순 안정 정렬 → 값 속의 @다른키 도 Java 와 같은 순서로 치환된다
+    keys = sorted(hash_order(list(params)), key=len, reverse=True)
+    for k in keys:
+        v = params[k]
+        s = re.sub('@' + k, lambda m, v=v: v, s)
+    return s
+
+
+def _parse_if_then_else(s):
+    spans = _find_spans(s, '{', '}')
+    ites = _link_if_then_elses(s, spans)
+    result = s
+    for ite in ites:
+        if ite.condition.valid:
+            cond = substring(result, ite.condition.start + 1, ite.condition.end - 1)
+            if _evaluate_condition(cond):
+                result = _replace(result, spans, ite.start(), ite.end(), ite.if_true.start + 1, ite.if_true.end - 2)
+            elif ite.has_if_false:
+                result = _replace(result, spans, ite.start(), ite.end(), ite.if_false.start + 1, ite.if_false.end - 2)
+            else:
+                result = _replace(result, spans, ite.start(), ite.end(), 0, -1)
+    return result
+
+
+def render_sql(sql, parameters=None, values=None):
+    """SqlRender.renderSql(sql, String[] parameters, String[] values) 와 같은 결과."""
+    params = {}
+    if parameters is not None:
+        for p, v in zip(parameters, values):
+            params[p] = v
+    return _parse_if_then_else(_substitute_parameters(sql, params))
+
+
+def check(sql, parameters=None, values=None):
+    return [f"Parameter '{p}' not found in SQL" for p in (parameters or []) if '@' + p not in sql]