sqlflip 0.1.1__tar.gz

sqlflip-0.1.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Your Name
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

sqlflip-0.1.1/PKG-INFO

@@ -0,0 +1,80 @@
+Metadata-Version: 2.4
+Name: sqlflip
+Version: 0.1.1
+Summary: Detect a SQL query's dialect and view it in PostgreSQL, MySQL, SQL Server and standard SQL.
+Author-email: anuvishalp <anuvishalp@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/anuvishalp/sqlflip-view
+Project-URL: Source, https://github.com/anuvishalp/sqlflip-view
+Project-URL: Issues, https://github.com/anuvishalp/sqlflip-view/issues
+Keywords: sql,postgresql,mysql,tsql,sqlserver,sql-converter,sql-dialect
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Database
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# sqlflip
+
+Paste a SQL query and `sqlflip` will:
+
+1. **Detect** which dialect it is written in - PostgreSQL, MySQL, SQL Server (T-SQL) or standard SQL.
+2. **Convert** it to the other dialects (identifier quoting, `TOP` / `LIMIT` / `OFFSET .. FETCH`,
+   `GETDATE()` / `NOW()`, `ISNULL` / `IFNULL` / `COALESCE`, `LEN` / `LENGTH`, common data types).
+3. **Display** all versions in a small window (Tkinter, no extra dependencies).
+
+> T-SQL is the language of SQL Server, so `tsql` and `sqlserver` mean the same thing.
+
+## Install
+
+```bash
+pip install sqlflip
+```
+
+(On Linux you may also need `sudo apt install python3-tk` for the window.)
+
+## Use in Python
+
+```python
+from sqlflip import detect_dialect, convert, convert_all, display
+
+q = "SELECT TOP 10 [name], ISNULL([age], 0) FROM [users] ORDER BY [name]"
+
+print(detect_dialect(q))            # SQL Server (T-SQL) (confidence: high)
+print(convert(q, "postgresql").sql) # SELECT "name", COALESCE("age", 0) FROM "users" ORDER BY "name" LIMIT 10
+print(convert(q, "mysql").sql)      # SELECT `name`, IFNULL(`age`, 0) FROM `users` ORDER BY `name` LIMIT 10
+
+for dialect, result in convert_all(q).items():
+    print(dialect, "->", result.sql, result.notes)
+
+display(q)                          # opens the window
+```
+
+## Command line
+
+```bash
+sqlflip "SELECT TOP 5 * FROM users"
+sqlflip "SELECT * FROM users LIMIT 5, 10" --to sqlserver
+sqlflip --gui
+```
+
+## Limitations
+
+This is a lightweight, rule-based tool - **not** a full SQL parser. Always review the output.
+Constructs it cannot safely translate (e.g. `::` casts, `||` / `+` string concatenation,
+auto-increment columns, `GROUP_CONCAT` / `STRING_AGG`, date functions, variables) are left as-is
+and reported in `result.notes`. Detection is heuristic: a query such as `SELECT * FROM t LIMIT 5`
+is valid in both PostgreSQL and MySQL, so it is reported as ambiguous.
+
+## Publish to PyPI
+
+```bash
+pip install build twine
+python -m build
+twine upload dist/*        # username: __token__   password: <your API token>
+```

sqlflip-0.1.1/README.md

@@ -0,0 +1,59 @@
+# sqlflip
+
+Paste a SQL query and `sqlflip` will:
+
+1. **Detect** which dialect it is written in - PostgreSQL, MySQL, SQL Server (T-SQL) or standard SQL.
+2. **Convert** it to the other dialects (identifier quoting, `TOP` / `LIMIT` / `OFFSET .. FETCH`,
+   `GETDATE()` / `NOW()`, `ISNULL` / `IFNULL` / `COALESCE`, `LEN` / `LENGTH`, common data types).
+3. **Display** all versions in a small window (Tkinter, no extra dependencies).
+
+> T-SQL is the language of SQL Server, so `tsql` and `sqlserver` mean the same thing.
+
+## Install
+
+```bash
+pip install sqlflip
+```
+
+(On Linux you may also need `sudo apt install python3-tk` for the window.)
+
+## Use in Python
+
+```python
+from sqlflip import detect_dialect, convert, convert_all, display
+
+q = "SELECT TOP 10 [name], ISNULL([age], 0) FROM [users] ORDER BY [name]"
+
+print(detect_dialect(q))            # SQL Server (T-SQL) (confidence: high)
+print(convert(q, "postgresql").sql) # SELECT "name", COALESCE("age", 0) FROM "users" ORDER BY "name" LIMIT 10
+print(convert(q, "mysql").sql)      # SELECT `name`, IFNULL(`age`, 0) FROM `users` ORDER BY `name` LIMIT 10
+
+for dialect, result in convert_all(q).items():
+    print(dialect, "->", result.sql, result.notes)
+
+display(q)                          # opens the window
+```
+
+## Command line
+
+```bash
+sqlflip "SELECT TOP 5 * FROM users"
+sqlflip "SELECT * FROM users LIMIT 5, 10" --to sqlserver
+sqlflip --gui
+```
+
+## Limitations
+
+This is a lightweight, rule-based tool - **not** a full SQL parser. Always review the output.
+Constructs it cannot safely translate (e.g. `::` casts, `||` / `+` string concatenation,
+auto-increment columns, `GROUP_CONCAT` / `STRING_AGG`, date functions, variables) are left as-is
+and reported in `result.notes`. Detection is heuristic: a query such as `SELECT * FROM t LIMIT 5`
+is valid in both PostgreSQL and MySQL, so it is reported as ambiguous.
+
+## Publish to PyPI
+
+```bash
+pip install build twine
+python -m build
+twine upload dist/*        # username: __token__   password: <your API token>
+```

sqlflip-0.1.1/pyproject.toml

@@ -0,0 +1,33 @@
+[build-system]
+requires = ["setuptools>=61", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "sqlflip"
+version = "0.1.1"
+description = "Detect a SQL query's dialect and view it in PostgreSQL, MySQL, SQL Server and standard SQL."
+readme = "README.md"
+license = {text = "MIT"}
+authors = [{name = "anuvishalp", email = "anuvishalp@gmail.com"}]
+requires-python = ">=3.8"
+keywords = ["sql", "postgresql", "mysql", "tsql", "sqlserver", "sql-converter", "sql-dialect"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Topic :: Database",
+]
+
+[project.urls]
+Homepage = "https://github.com/anuvishalp/sqlflip-view"
+Source = "https://github.com/anuvishalp/sqlflip-view"
+Issues = "https://github.com/anuvishalp/sqlflip-view/issues"
+
+[project.scripts]
+sqlflip = "sqlflip.cli:main"
+sqlflip-gui = "sqlflip.gui:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]

sqlflip-0.1.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

sqlflip-0.1.1/src/sqlflip/__init__.py

@@ -0,0 +1,13 @@
+"""sqlflip - detect a SQL query's dialect and view it in other dialects."""
+from .converter import Conversion, convert, convert_all
+from .detector import DIALECTS, DISPLAY_NAMES, Detection, detect_dialect
+
+__version__ = "0.1.0"
+__all__ = ["detect_dialect", "convert", "convert_all", "display",
+           "Detection", "Conversion", "DIALECTS", "DISPLAY_NAMES"]
+
+
+def display(query: str = "") -> None:
+    """Open a window showing `query` in PostgreSQL, MySQL, SQL Server and standard SQL."""
+    from .gui import show   # imported lazily so the library works without Tkinter
+    show(query)

sqlflip-0.1.1/src/sqlflip/__main__.py

@@ -0,0 +1,4 @@
+import sys
+from .cli import main
+
+sys.exit(main())

sqlflip-0.1.1/src/sqlflip/_utils.py

@@ -0,0 +1,22 @@
+"""Small helpers shared by the detector and the converter."""
+import re
+from typing import List, Tuple
+
+_STRING_RE = re.compile(r"'(?:[^']|'')*'")
+
+
+def mask_strings(sql: str) -> Tuple[str, List[str]]:
+    """Replace every 'string literal' with a placeholder so regex rules
+    never touch text that lives inside quotes."""
+    strings: List[str] = []
+
+    def _sub(match):
+        strings.append(match.group(0))
+        return "\x00%d\x00" % (len(strings) - 1)
+
+    return _STRING_RE.sub(_sub, sql), strings
+
+
+def unmask_strings(sql: str, strings: List[str]) -> str:
+    """Put the original string literals back."""
+    return re.sub(r"\x00(\d+)\x00", lambda m: strings[int(m.group(1))], sql)

sqlflip-0.1.1/src/sqlflip/cli.py

@@ -0,0 +1,53 @@
+"""Command-line interface:  sqlflip "SELECT TOP 5 * FROM users" """
+import argparse
+import sys
+
+from .converter import convert, convert_all
+from .detector import DIALECTS, DISPLAY_NAMES, detect_dialect, normalize_dialect
+
+
+def main(argv=None) -> int:
+    parser = argparse.ArgumentParser(
+        prog="sqlflip", description="Detect a query's SQL dialect and convert it.")
+    parser.add_argument("query", nargs="?", help="SQL text (or use --file / pipe via stdin)")
+    parser.add_argument("-f", "--file", help="read the query from a file")
+    parser.add_argument("--from", dest="source", help="source dialect (default: auto-detect)")
+    parser.add_argument("--to", dest="target", help="show only this target dialect")
+    parser.add_argument("--gui", action="store_true", help="open the display window")
+    args = parser.parse_args(argv)
+
+    query = args.query
+    if args.file:
+        with open(args.file, encoding="utf-8") as fh:
+            query = fh.read()
+    elif query is None and not sys.stdin.isatty():
+        query = sys.stdin.read()
+
+    if args.gui or not query:
+        from .gui import show
+        show(query or "")
+        return 0
+
+    detection = detect_dialect(query)
+    source = normalize_dialect(args.source) if args.source else detection.dialect
+    print("Detected : %s" % detection)
+    if args.source:
+        print("Using    : %s" % DISPLAY_NAMES[source])
+    print()
+
+    if args.target:
+        results = {normalize_dialect(args.target): convert(query, args.target, source)}
+    else:
+        results = convert_all(query, source)
+
+    for d, res in results.items():
+        print("--- %s %s---" % (DISPLAY_NAMES[d], "(source) " if d == source else ""))
+        print(res.sql)
+        for note in res.notes:
+            print("  ! " + note)
+        print()
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

sqlflip-0.1.1/src/sqlflip/converter.py

@@ -0,0 +1,244 @@
+"""Convert a SQL query from one dialect to another.
+
+This is a lightweight, rule-based converter. It handles the most common
+differences (identifier quoting, row limiting, a handful of functions and data
+types) and *warns* about constructs it cannot translate safely.
+"""
+import re
+from dataclasses import dataclass, field
+from typing import Dict, List, Optional, Tuple
+
+from ._utils import mask_strings, unmask_strings
+from .detector import DIALECTS, detect_dialect, normalize_dialect
+
+
+@dataclass
+class Conversion:
+    dialect: str
+    sql: str
+    notes: List[str] = field(default_factory=list)
+
+
+# --------------------------------------------------------------------------
+# 1. Identifier quoting:  [name]  `name`  "name"
+# --------------------------------------------------------------------------
+_QUOTE = {
+    "postgresql": ('"', '"'),
+    "standard": ('"', '"'),
+    "mysql": ("`", "`"),
+    "sqlserver": ("[", "]"),
+}
+
+
+def _requote(text: str, source: str, target: str) -> str:
+    opener, closer = _QUOTE[target]
+    if source == "sqlserver":
+        patterns = [r"\[([^\]\x00]+)\]", r'"([^"\x00]+)"']
+    elif source == "mysql":
+        patterns = [r"`([^`]+)`"]
+    else:
+        patterns = [r'"([^"\x00]+)"']
+    for pattern in patterns:
+        text = re.sub(pattern, lambda m: "%s%s%s" % (opener, m.group(1), closer), text)
+    return text
+
+
+# --------------------------------------------------------------------------
+# 2. Row limiting:  TOP n  /  LIMIT n [OFFSET m]  /  OFFSET m ROWS FETCH ...
+# --------------------------------------------------------------------------
+_TOP = re.compile(r"\bSELECT(\s+DISTINCT)?\s+TOP\s*\(?\s*(\d+)\s*\)?\s+", re.I)
+_LIMIT_COMMA = re.compile(r"\s*\bLIMIT\s+(\d+)\s*,\s*(\d+)", re.I)
+_LIMIT = re.compile(r"\s*\bLIMIT\s+(\d+)(?:\s+OFFSET\s+(\d+))?", re.I)
+_OFFSET_FETCH = re.compile(
+    r"\s*\bOFFSET\s+(\d+)\s+ROWS?(?:\s+FETCH\s+(?:FIRST|NEXT)\s+(\d+)\s+ROWS?\s+ONLY)?", re.I
+)
+_FETCH_ONLY = re.compile(r"\s*\bFETCH\s+(?:FIRST|NEXT)\s+(\d+)\s+ROWS?\s+ONLY", re.I)
+
+
+def _cut(text: str, match) -> str:
+    return text[: match.start()] + text[match.end():]
+
+
+def _extract_limit(text: str) -> Tuple[str, Optional[int], Optional[int]]:
+    """Remove any row-limit clause and return (text, limit, offset)."""
+    limit = offset = None
+
+    m = _TOP.search(text)
+    if m:
+        limit = int(m.group(2))
+        text = text[: m.start()] + "SELECT" + (m.group(1) or "") + " " + text[m.end():]
+        return text, limit, offset
+
+    m = _LIMIT_COMMA.search(text)          # MySQL: LIMIT offset, count
+    if m:
+        return _cut(text, m), int(m.group(2)), int(m.group(1))
+
+    m = _LIMIT.search(text)                # LIMIT n [OFFSET m]
+    if m:
+        off = int(m.group(2)) if m.group(2) else None
+        return _cut(text, m), int(m.group(1)), off
+
+    m = _OFFSET_FETCH.search(text)         # OFFSET m ROWS [FETCH NEXT n ROWS ONLY]
+    if m:
+        lim = int(m.group(2)) if m.group(2) else None
+        return _cut(text, m), lim, int(m.group(1))
+
+    m = _FETCH_ONLY.search(text)           # FETCH FIRST n ROWS ONLY
+    if m:
+        return _cut(text, m), int(m.group(1)), None
+
+    return text, None, None
+
+
+def _apply_limit(text: str, limit: Optional[int], offset: Optional[int], target: str) -> str:
+    if limit is None and not offset:
+        return text
+
+    if target in ("postgresql", "mysql"):
+        if target == "mysql" and limit is None:
+            limit = 18446744073709551615   # MySQL needs a LIMIT to use OFFSET
+        clause = ""
+        if limit is not None:
+            clause += " LIMIT %d" % limit
+        if offset:
+            clause += " OFFSET %d" % offset
+        return text + clause
+
+    if target == "standard":
+        clause = ""
+        if offset:
+            clause += " OFFSET %d ROWS" % offset
+        if limit is not None:
+            clause += " FETCH NEXT %d ROWS ONLY" % limit
+        return text + clause
+
+    # SQL Server
+    if not offset:
+        return re.sub(
+            r"^(\s*SELECT(?:\s+DISTINCT)?)\s+",
+            lambda m: "%s TOP %d " % (m.group(1), limit),
+            text, count=1, flags=re.I,
+        )
+    if not re.search(r"\bORDER\s+BY\b", text, re.I):
+        text += " ORDER BY (SELECT NULL)"   # OFFSET/FETCH requires ORDER BY
+    text += " OFFSET %d ROWS" % offset
+    if limit is not None:
+        text += " FETCH NEXT %d ROWS ONLY" % limit
+    return text
+
+
+# --------------------------------------------------------------------------
+# 3. Functions
+# --------------------------------------------------------------------------
+_NOW = {"sqlserver": "GETDATE()", "mysql": "NOW()", "postgresql": "NOW()",
+        "standard": "CURRENT_TIMESTAMP"}
+_NULLFN = {"sqlserver": "ISNULL", "mysql": "IFNULL", "postgresql": "COALESCE",
+           "standard": "COALESCE"}
+_LENFN = {"sqlserver": "LEN", "mysql": "CHAR_LENGTH", "postgresql": "LENGTH",
+          "standard": "CHAR_LENGTH"}
+
+
+def _convert_functions(text: str, source: str, target: str) -> str:
+    text = re.sub(r"\b(?:GETDATE|SYSDATETIME|NOW|CURRENT_TIMESTAMP)\s*\(\s*\)",
+                  _NOW[target], text, flags=re.I)
+
+    null_names = "IFNULL|ISNULL" if source == "sqlserver" else "IFNULL"
+    text = re.sub(r"\b(?:%s)\s*\(" % null_names, _NULLFN[target] + "(", text, flags=re.I)
+
+    text = re.sub(r"\b(?:LEN|LENGTH|CHAR_LENGTH|CHARACTER_LENGTH)\s*\(",
+                  _LENFN[target] + "(", text, flags=re.I)
+    return text
+
+
+# --------------------------------------------------------------------------
+# 4. Data types (only for CREATE / ALTER statements)
+# --------------------------------------------------------------------------
+_TYPES = {
+    "sqlserver": [(r"\bBOOLEAN\b", "BIT"), (r"\bTIMESTAMP\b", "DATETIME2"),
+                  (r"\bTEXT\b", "NVARCHAR(MAX)")],
+    "mysql": [(r"\bN?VARCHAR\s*\(\s*MAX\s*\)", "TEXT"), (r"\bNVARCHAR\b", "VARCHAR"),
+              (r"\bDATETIME2\b", "DATETIME"), (r"\bBIT\b", "BOOLEAN")],
+    "postgresql": [(r"\bN?VARCHAR\s*\(\s*MAX\s*\)", "TEXT"), (r"\bNVARCHAR\b", "VARCHAR"),
+                   (r"\b(?:DATETIME2|DATETIME)\b", "TIMESTAMP"), (r"\bBIT\b", "BOOLEAN"),
+                   (r"\bTINYINT\b", "SMALLINT")],
+}
+_TYPES["standard"] = _TYPES["postgresql"]
+
+
+def _convert_types(text: str, target: str) -> str:
+    if not re.match(r"\s*(CREATE|ALTER)\b", text, re.I):
+        return text
+    for pattern, repl in _TYPES[target]:
+        text = re.sub(pattern, repl, text, flags=re.I)
+    return text
+
+
+# --------------------------------------------------------------------------
+# 5. Warnings for things we do NOT translate
+# --------------------------------------------------------------------------
+def _collect_notes(masked: str, source: str, target: str) -> List[str]:
+    notes: List[str] = []
+
+    def has(pattern: str) -> bool:
+        return re.search(pattern, masked, re.I) is not None
+
+    if has(r"::\s*\w+") and target != "postgresql":
+        notes.append("PostgreSQL '::' casts were not converted - rewrite as CAST(expr AS type).")
+    if has(r"\|\|") and target in ("mysql", "sqlserver"):
+        notes.append("String concatenation with '||' was not converted - use CONCAT() "
+                     "(MySQL / SQL Server) or '+' (SQL Server).")
+    if source == "sqlserver" and target != "sqlserver" and has(r"\x00\d+\x00\s*\+|\+\s*\x00\d+\x00"):
+        notes.append("String concatenation with '+' was not converted - use CONCAT() or '||'.")
+    if has(r"\b(AUTO_INCREMENT|IDENTITY|SERIAL|BIGSERIAL)\b"):
+        notes.append("Auto-increment columns differ (AUTO_INCREMENT / IDENTITY / SERIAL) - review manually.")
+    if has(r"\b(GROUP_CONCAT|STRING_AGG)\s*\("):
+        notes.append("GROUP_CONCAT / STRING_AGG are not converted - review manually.")
+    if has(r"\b(DATEADD|DATE_ADD|DATEDIFF|DATE_FORMAT|TO_CHAR|CONVERT|INTERVAL)\b"):
+        notes.append("Date/time functions differ a lot between dialects - review manually.")
+    if has(r"(?<![\w@])@\w+|\$\d+"):
+        notes.append("Variables / parameters (@name, $1) were not converted.")
+    return notes
+
+
+# --------------------------------------------------------------------------
+# Public API
+# --------------------------------------------------------------------------
+def convert(query: str, target: str, source: Optional[str] = None) -> Conversion:
+    """Convert `query` to the `target` dialect.
+
+    If `source` is omitted the dialect is auto-detected.
+    """
+    target = normalize_dialect(target)
+    body = (query or "").strip()
+    if not body:
+        raise ValueError("The query is empty.")
+    src = normalize_dialect(source) if source else detect_dialect(body).dialect
+
+    if src == target:
+        return Conversion(target, body, [])
+
+    masked, strings = mask_strings(body)
+    notes = _collect_notes(masked, src, target)
+
+    text = masked.rstrip()
+    had_semicolon = text.endswith(";")
+    text = text.rstrip(";").rstrip()
+
+    text = _requote(text, src, target)
+    text, limit, offset = _extract_limit(text)
+    text = _apply_limit(text, limit, offset, target)
+    text = _convert_functions(text, src, target)
+    text = _convert_types(text, target)
+
+    if had_semicolon:
+        text += ";"
+    return Conversion(target, unmask_strings(text, strings), notes)
+
+
+def convert_all(query: str, source: Optional[str] = None) -> Dict[str, Conversion]:
+    """Return the query in every supported dialect."""
+    body = (query or "").strip()
+    if not body:
+        raise ValueError("The query is empty.")
+    src = normalize_dialect(source) if source else detect_dialect(body).dialect
+    return {d: convert(body, d, src) for d in DIALECTS}

sqlflip-0.1.1/src/sqlflip/detector.py

@@ -0,0 +1,146 @@
+"""Detect which SQL dialect a query is written in."""
+import re
+from dataclasses import dataclass, field
+from typing import Dict, List, Tuple
+
+from ._utils import mask_strings
+
+# Order matters: it is also the tie-break order and the tab order in the GUI.
+DIALECTS = ("postgresql", "mysql", "sqlserver", "standard")
+
+DISPLAY_NAMES = {
+    "postgresql": "PostgreSQL",
+    "mysql": "MySQL",
+    "sqlserver": "SQL Server (T-SQL)",
+    "standard": "Standard SQL",
+}
+
+# T-SQL *is* the language of SQL Server, so both names map to "sqlserver".
+_ALIASES = {
+    "postgresql": "postgresql", "postgres": "postgresql", "pg": "postgresql",
+    "psql": "postgresql", "plpgsql": "postgresql",
+    "mysql": "mysql", "mariadb": "mysql",
+    "sqlserver": "sqlserver", "sql server": "sqlserver", "sql_server": "sqlserver",
+    "tsql": "sqlserver", "t-sql": "sqlserver", "mssql": "sqlserver",
+    "standard": "standard", "sql": "standard", "ansi": "standard",
+}
+
+
+def normalize_dialect(name: str) -> str:
+    key = (name or "").strip().lower()
+    if key not in _ALIASES:
+        raise ValueError(
+            "Unknown dialect %r. Use one of: postgresql, mysql, sqlserver "
+            "(or tsql), standard (or sql)." % name
+        )
+    return _ALIASES[key]
+
+
+# (dialect, regex, weight, human-readable label)
+_RULES: List[Tuple[str, str, int, str]] = [
+    # ---- SQL Server / T-SQL ------------------------------------------------
+    ("sqlserver", r"\bSELECT\s+(DISTINCT\s+)?TOP\s*\(?\s*\d+", 3, "SELECT TOP n"),
+    ("sqlserver", r"(?<![\w\)\]])\[[A-Za-z_][\w ]*\]", 3, "[bracket] identifiers"),
+    ("sqlserver", r"\bGETDATE\s*\(|\bSYSDATETIME\s*\(", 3, "GETDATE()"),
+    ("sqlserver", r"\bISNULL\s*\([^,()]+,", 2, "ISNULL(a, b)"),
+    ("sqlserver", r"\bLEN\s*\(", 2, "LEN()"),
+    ("sqlserver", r"\bDATEADD\s*\(", 2, "DATEADD()"),
+    ("sqlserver", r"\bNVARCHAR\b|\bDATETIME2\b|\bUNIQUEIDENTIFIER\b|\bNEWID\s*\(", 2, "SQL Server data types"),
+    ("sqlserver", r"\bWITH\s*\(\s*NOLOCK\s*\)", 3, "WITH (NOLOCK)"),
+    ("sqlserver", r"\bIDENTITY\s*\(\s*\d+\s*,\s*\d+\s*\)", 3, "IDENTITY(1,1)"),
+    ("sqlserver", r"\bOFFSET\s+\d+\s+ROWS?\s+FETCH\b", 2, "OFFSET .. FETCH NEXT"),
+    ("sqlserver", r"\bdbo\.", 2, "dbo. schema"),
+    ("sqlserver", r"\bSET\s+NOCOUNT\b|\bEXEC(UTE)?\s+\w", 3, "EXEC / SET NOCOUNT"),
+    ("sqlserver", r"\b(FROM|INTO|JOIN)\s+#\w+", 3, "#temp tables"),
+    ("sqlserver", r"\bCONVERT\s*\(\s*\w+(\(\s*\w+\s*\))?\s*,", 2, "CONVERT(type, x)"),
+    ("sqlserver", r"(?<![\w@])@\w+", 1, "@variables"),
+    ("sqlserver", r"\bSTRING_AGG\s*\(", 1, "STRING_AGG()"),
+    # ---- MySQL -------------------------------------------------------------
+    ("mysql", r"`[^`]+`", 3, "`backtick` identifiers"),
+    ("mysql", r"\bLIMIT\s+\d+\s*,\s*\d+", 3, "LIMIT offset, count"),
+    ("mysql", r"\bIFNULL\s*\(", 2, "IFNULL()"),
+    ("mysql", r"\bAUTO_INCREMENT\b", 3, "AUTO_INCREMENT"),
+    ("mysql", r"\bENGINE\s*=", 3, "ENGINE="),
+    ("mysql", r"\b(CURDATE|CURTIME|UNIX_TIMESTAMP)\s*\(", 2, "CURDATE()/CURTIME()"),
+    ("mysql", r"\bGROUP_CONCAT\s*\(", 3, "GROUP_CONCAT()"),
+    ("mysql", r"\bON\s+DUPLICATE\s+KEY\s+UPDATE\b", 3, "ON DUPLICATE KEY UPDATE"),
+    ("mysql", r"\bINSERT\s+IGNORE\b", 3, "INSERT IGNORE"),
+    ("mysql", r"\bDATE_FORMAT\s*\(", 2, "DATE_FORMAT()"),
+    ("mysql", r"^\s*SHOW\s+(TABLES|DATABASES|COLUMNS)\b", 2, "SHOW TABLES"),
+    ("mysql", r"\bUNSIGNED\b|\bTINYINT\s*\(", 2, "MySQL data types"),
+    ("mysql", r"\bLIMIT\s+\d+", 1, "LIMIT n"),
+    ("mysql", r"\bNOW\s*\(\s*\)", 1, "NOW()"),
+    ("mysql", r"(?<![\w@])@\w+", 1, "@variables"),
+    # ---- PostgreSQL --------------------------------------------------------
+    ("postgresql", r"::\s*\w+", 3, ":: type cast"),
+    ("postgresql", r"\bILIKE\b", 3, "ILIKE"),
+    ("postgresql", r"\bRETURNING\b", 3, "RETURNING"),
+    ("postgresql", r"\b(BIG)?SERIAL\b", 3, "SERIAL"),
+    ("postgresql", r"\$\d+", 3, "$1 parameters"),
+    ("postgresql", r"\bGENERATE_SERIES\s*\(", 3, "GENERATE_SERIES()"),
+    ("postgresql", r"\bJSONB\b", 3, "JSONB"),
+    ("postgresql", r"\bARRAY\s*\[", 3, "ARRAY[...]"),
+    ("postgresql", r"\bON\s+CONFLICT\b", 3, "ON CONFLICT"),
+    ("postgresql", r"\bTO_CHAR\s*\(|\bTO_DATE\s*\(", 2, "TO_CHAR()/TO_DATE()"),
+    ("postgresql", r"\bSTRING_AGG\s*\(", 2, "STRING_AGG()"),
+    ("postgresql", r"\|\|", 1, "|| concatenation"),
+    ("postgresql", r"\bLIMIT\s+\d+", 1, "LIMIT n"),
+    ("postgresql", r"\bNOW\s*\(\s*\)", 1, "NOW()"),
+    # ---- Standard SQL ------------------------------------------------------
+    ("standard", r"\bFETCH\s+FIRST\s+\d+\s+ROWS?\s+ONLY\b", 2, "FETCH FIRST n ROWS ONLY"),
+    ("standard", r"\bCURRENT_TIMESTAMP\b", 1, "CURRENT_TIMESTAMP"),
+    ("standard", r"\bCOALESCE\s*\(", 1, "COALESCE()"),
+    ("standard", r"\|\|", 1, "|| concatenation"),
+]
+
+_COMPILED = [(d, re.compile(p, re.I | re.M), w, lbl) for d, p, w, lbl in _RULES]
+
+
+@dataclass
+class Detection:
+    dialect: str                      # best guess
+    candidates: List[str]             # all dialects tied for first place
+    scores: Dict[str, int]
+    evidence: List[Tuple[str, str]] = field(default_factory=list)
+    confidence: str = "low"           # low / medium / high
+
+    @property
+    def display_name(self) -> str:
+        return DISPLAY_NAMES[self.dialect]
+
+    @property
+    def ambiguous(self) -> bool:
+        return len(self.candidates) > 1
+
+    def __str__(self) -> str:
+        if self.ambiguous:
+            names = " or ".join(DISPLAY_NAMES[c] for c in self.candidates)
+            return "Ambiguous: could be %s (confidence: low)" % names
+        return "%s (confidence: %s)" % (self.display_name, self.confidence)
+
+
+def detect_dialect(query: str) -> Detection:
+    """Guess the SQL dialect of `query` by scoring dialect-specific syntax."""
+    masked, _ = mask_strings(query)
+    scores = {d: 0 for d in DIALECTS}
+    evidence: List[Tuple[str, str]] = []
+
+    for dialect, rx, weight, label in _COMPILED:
+        if rx.search(masked):
+            scores[dialect] += weight
+            evidence.append((dialect, label))
+
+    top = max(scores.values())
+    if top == 0:
+        # Nothing dialect-specific found -> plain SQL that runs almost anywhere.
+        return Detection("standard", ["standard"], scores, [], "low")
+
+    candidates = [d for d in DIALECTS if scores[d] == top]
+    second = sorted(scores.values(), reverse=True)[1]
+    if len(candidates) > 1:
+        confidence = "low"
+    elif top >= 3 and top >= 2 * second:
+        confidence = "high"
+    else:
+        confidence = "medium"
+    return Detection(candidates[0], candidates, scores, evidence, confidence)

sqlflip-0.1.1/src/sqlflip/gui.py

@@ -0,0 +1,107 @@
+"""A small Tkinter window that shows a query in every SQL dialect."""
+import tkinter as tk
+from tkinter import ttk
+
+from .converter import convert_all
+from .detector import DIALECTS, DISPLAY_NAMES, detect_dialect, normalize_dialect
+
+_AUTO = "Auto-detect"
+_MONO = ("Consolas", 11)
+
+
+def show(query: str = "") -> None:
+    """Open the window. Optionally pre-fill it with `query`."""
+    root = tk.Tk()
+    root.title("sqlflip - SQL dialect detector & converter")
+    root.geometry("920x680")
+    root.minsize(700, 520)
+
+    main = ttk.Frame(root, padding=10)
+    main.pack(fill="both", expand=True)
+
+    # ---- input --------------------------------------------------------------
+    ttk.Label(main, text="Paste your SQL query:").pack(anchor="w")
+    input_box = tk.Text(main, height=8, font=_MONO, wrap="word", undo=True)
+    input_box.pack(fill="x", pady=(2, 8))
+    input_box.insert("1.0", query)
+
+    # ---- controls -----------------------------------------------------------
+    controls = ttk.Frame(main)
+    controls.pack(fill="x")
+    ttk.Label(controls, text="Source dialect:").pack(side="left")
+    source_var = tk.StringVar(value=_AUTO)
+    ttk.Combobox(
+        controls, textvariable=source_var, state="readonly", width=20,
+        values=[_AUTO] + [DISPLAY_NAMES[d] for d in DIALECTS],
+    ).pack(side="left", padx=6)
+
+    status_var = tk.StringVar(value="Paste a query and click 'Detect & Convert'.")
+    ttk.Label(main, textvariable=status_var, font=("Segoe UI", 10, "bold")).pack(anchor="w", pady=(8, 4))
+
+    # ---- one tab per dialect --------------------------------------------------
+    notebook = ttk.Notebook(main)
+    notebook.pack(fill="both", expand=True)
+    outputs, note_vars = {}, {}
+
+    def make_copy(d):
+        def _copy():
+            root.clipboard_clear()
+            root.clipboard_append(outputs[d].get("1.0", "end").strip())
+        return _copy
+
+    for d in DIALECTS:
+        tab = ttk.Frame(notebook, padding=6)
+        notebook.add(tab, text=DISPLAY_NAMES[d])
+        box = tk.Text(tab, font=_MONO, wrap="word", state="disabled", bg="#f6f6f6")
+        box.pack(fill="both", expand=True)
+        outputs[d] = box
+        note_vars[d] = tk.StringVar()
+        ttk.Label(tab, textvariable=note_vars[d], foreground="#a05a00",
+                  wraplength=840, justify="left").pack(anchor="w", pady=(6, 0))
+        ttk.Button(tab, text="Copy", command=make_copy(d)).pack(anchor="e", pady=(6, 0))
+
+    # ---- actions -----------------------------------------------------------
+    def run():
+        q = input_box.get("1.0", "end").strip()
+        if not q:
+            status_var.set("Please paste a SQL query first.")
+            return
+        detection = detect_dialect(q)
+        chosen = source_var.get()
+        if chosen == _AUTO:
+            source = detection.dialect
+            status_var.set("Detected: %s" % detection)
+        else:
+            source = next(d for d in DIALECTS if DISPLAY_NAMES[d] == chosen)
+            status_var.set("Using source dialect: %s" % chosen)
+
+        results = convert_all(q, source)
+        for i, d in enumerate(DIALECTS):
+            box = outputs[d]
+            box.config(state="normal")
+            box.delete("1.0", "end")
+            box.insert("1.0", results[d].sql)
+            box.config(state="disabled")
+            note_vars[d].set("\n".join("! " + n for n in results[d].notes))
+            title = DISPLAY_NAMES[d] + ("  (source)" if d == source else "")
+            notebook.tab(i, text=title)
+        notebook.select(DIALECTS.index(source))
+
+    def clear():
+        input_box.delete("1.0", "end")
+        status_var.set("Paste a query and click 'Detect & Convert'.")
+
+    ttk.Button(controls, text="Detect & Convert", command=run).pack(side="left", padx=6)
+    ttk.Button(controls, text="Clear", command=clear).pack(side="left")
+
+    if query.strip():
+        run()
+    root.mainloop()
+
+
+def main() -> None:
+    show()
+
+
+if __name__ == "__main__":
+    main()

sqlflip-0.1.1/src/sqlflip.egg-info/PKG-INFO

@@ -0,0 +1,80 @@
+Metadata-Version: 2.4
+Name: sqlflip
+Version: 0.1.1
+Summary: Detect a SQL query's dialect and view it in PostgreSQL, MySQL, SQL Server and standard SQL.
+Author-email: anuvishalp <anuvishalp@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/anuvishalp/sqlflip-view
+Project-URL: Source, https://github.com/anuvishalp/sqlflip-view
+Project-URL: Issues, https://github.com/anuvishalp/sqlflip-view/issues
+Keywords: sql,postgresql,mysql,tsql,sqlserver,sql-converter,sql-dialect
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Database
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# sqlflip
+
+Paste a SQL query and `sqlflip` will:
+
+1. **Detect** which dialect it is written in - PostgreSQL, MySQL, SQL Server (T-SQL) or standard SQL.
+2. **Convert** it to the other dialects (identifier quoting, `TOP` / `LIMIT` / `OFFSET .. FETCH`,
+   `GETDATE()` / `NOW()`, `ISNULL` / `IFNULL` / `COALESCE`, `LEN` / `LENGTH`, common data types).
+3. **Display** all versions in a small window (Tkinter, no extra dependencies).
+
+> T-SQL is the language of SQL Server, so `tsql` and `sqlserver` mean the same thing.
+
+## Install
+
+```bash
+pip install sqlflip
+```
+
+(On Linux you may also need `sudo apt install python3-tk` for the window.)
+
+## Use in Python
+
+```python
+from sqlflip import detect_dialect, convert, convert_all, display
+
+q = "SELECT TOP 10 [name], ISNULL([age], 0) FROM [users] ORDER BY [name]"
+
+print(detect_dialect(q))            # SQL Server (T-SQL) (confidence: high)
+print(convert(q, "postgresql").sql) # SELECT "name", COALESCE("age", 0) FROM "users" ORDER BY "name" LIMIT 10
+print(convert(q, "mysql").sql)      # SELECT `name`, IFNULL(`age`, 0) FROM `users` ORDER BY `name` LIMIT 10
+
+for dialect, result in convert_all(q).items():
+    print(dialect, "->", result.sql, result.notes)
+
+display(q)                          # opens the window
+```
+
+## Command line
+
+```bash
+sqlflip "SELECT TOP 5 * FROM users"
+sqlflip "SELECT * FROM users LIMIT 5, 10" --to sqlserver
+sqlflip --gui
+```
+
+## Limitations
+
+This is a lightweight, rule-based tool - **not** a full SQL parser. Always review the output.
+Constructs it cannot safely translate (e.g. `::` casts, `||` / `+` string concatenation,
+auto-increment columns, `GROUP_CONCAT` / `STRING_AGG`, date functions, variables) are left as-is
+and reported in `result.notes`. Detection is heuristic: a query such as `SELECT * FROM t LIMIT 5`
+is valid in both PostgreSQL and MySQL, so it is reported as ambiguous.
+
+## Publish to PyPI
+
+```bash
+pip install build twine
+python -m build
+twine upload dist/*        # username: __token__   password: <your API token>
+```

sqlflip-0.1.1/src/sqlflip.egg-info/SOURCES.txt

@@ -0,0 +1,16 @@
+LICENSE
+README.md
+pyproject.toml
+src/sqlflip/__init__.py
+src/sqlflip/__main__.py
+src/sqlflip/_utils.py
+src/sqlflip/cli.py
+src/sqlflip/converter.py
+src/sqlflip/detector.py
+src/sqlflip/gui.py
+src/sqlflip.egg-info/PKG-INFO
+src/sqlflip.egg-info/SOURCES.txt
+src/sqlflip.egg-info/dependency_links.txt
+src/sqlflip.egg-info/entry_points.txt
+src/sqlflip.egg-info/top_level.txt
+tests/test_sqlflip.py

sqlflip-0.1.1/src/sqlflip.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

sqlflip-0.1.1/src/sqlflip.egg-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+sqlflip = sqlflip.cli:main
+sqlflip-gui = sqlflip.gui:main

sqlflip-0.1.1/src/sqlflip.egg-info/top_level.txt

@@ -0,0 +1 @@
+sqlflip

sqlflip-0.1.1/tests/test_sqlflip.py

@@ -0,0 +1,73 @@
+import unittest
+
+from sqlflip import convert, convert_all, detect_dialect
+
+
+class DetectTests(unittest.TestCase):
+    def test_sqlserver(self):
+        self.assertEqual(detect_dialect("SELECT TOP 10 [name] FROM [users]").dialect, "sqlserver")
+
+    def test_mysql(self):
+        self.assertEqual(detect_dialect("SELECT `name` FROM `users` LIMIT 5, 10").dialect, "mysql")
+
+    def test_postgres(self):
+        self.assertEqual(detect_dialect("SELECT name FROM users WHERE name ILIKE 'a%'").dialect, "postgresql")
+
+    def test_plain_is_standard(self):
+        d = detect_dialect("SELECT name FROM users WHERE id = 1")
+        self.assertEqual(d.dialect, "standard")
+
+    def test_ambiguous_limit(self):
+        d = detect_dialect("SELECT name FROM users LIMIT 5")
+        self.assertTrue(d.ambiguous)
+
+    def test_strings_are_ignored(self):
+        d = detect_dialect("SELECT 'TOP 5 [x] ILIKE' FROM users")
+        self.assertEqual(d.dialect, "standard")
+
+
+class ConvertTests(unittest.TestCase):
+    Q = "SELECT TOP 10 [name], ISNULL([age], 0) FROM [users] ORDER BY [name]"
+
+    def test_sqlserver_to_postgres(self):
+        r = convert(self.Q, "postgresql")
+        self.assertEqual(r.sql, 'SELECT "name", COALESCE("age", 0) FROM "users" ORDER BY "name" LIMIT 10')
+
+    def test_sqlserver_to_mysql(self):
+        r = convert(self.Q, "mysql")
+        self.assertEqual(r.sql, "SELECT `name`, IFNULL(`age`, 0) FROM `users` ORDER BY `name` LIMIT 10")
+
+    def test_mysql_offset_to_sqlserver(self):
+        r = convert("SELECT `id` FROM `t` ORDER BY `id` LIMIT 5, 10", "tsql")
+        self.assertEqual(r.sql, "SELECT [id] FROM [t] ORDER BY [id] OFFSET 5 ROWS FETCH NEXT 10 ROWS ONLY")
+
+    def test_offset_without_order_by(self):
+        r = convert("SELECT id FROM t LIMIT 10 OFFSET 20", "sqlserver", source="postgresql")
+        self.assertIn("ORDER BY (SELECT NULL) OFFSET 20 ROWS FETCH NEXT 10 ROWS ONLY", r.sql)
+
+    def test_string_literals_untouched(self):
+        r = convert("SELECT TOP 3 'LIMIT 5 [x]' FROM [t]", "postgresql")
+        self.assertEqual(r.sql, "SELECT 'LIMIT 5 [x]' FROM \"t\" LIMIT 3")
+
+    def test_now_and_len(self):
+        r = convert("SELECT LEN(name), GETDATE() FROM t", "postgresql", source="sqlserver")
+        self.assertEqual(r.sql, "SELECT LENGTH(name), NOW() FROM t")
+
+    def test_semicolon_kept(self):
+        r = convert("SELECT TOP 1 * FROM t;", "mysql", source="sqlserver")
+        self.assertEqual(r.sql, "SELECT * FROM t LIMIT 1;")
+
+    def test_notes_for_cast(self):
+        r = convert("SELECT id::text FROM t", "mysql", source="postgresql")
+        self.assertTrue(r.notes)
+
+    def test_convert_all_has_four_dialects(self):
+        self.assertEqual(len(convert_all("SELECT 1")), 4)
+
+    def test_empty_query(self):
+        with self.assertRaises(ValueError):
+            convert("   ", "mysql")
+
+
+if __name__ == "__main__":
+    unittest.main()