sqlalchemy-cubrid 0.7.1__py3-none-any.whl

sqlalchemy_cubrid/compiler.py

@@ -0,0 +1,515 @@
+# sqlalchemy_cubrid/compiler.py
+# Copyright (C) 2021-2026 by sqlalchemy-cubrid authors and contributors
+# <see AUTHORS file>
+#
+# This module is part of sqlalchemy-cubrid and is released under
+# the MIT License: http://www.opensource.org/licenses/mit-license.php
+
+"""CUBRID SQL, DDL, and type compilers for SQLAlchemy 2.0."""
+
+from __future__ import annotations
+
+from sqlalchemy.sql import compiler
+from sqlalchemy.sql import sqltypes
+
+
+class CubridCompiler(compiler.SQLCompiler):
+    """SQLCompiler subclass for CUBRID."""
+
+    def visit_sysdate_func(self, fn, **kw):
+        return "SYSDATE"
+
+    def visit_utc_timestamp_func(self, fn, **kw):
+        return "UTC_TIMESTAMP()"
+
+    def visit_group_concat_func(self, fn, **kw):
+        """Render GROUP_CONCAT aggregate function.
+
+        CUBRID supports GROUP_CONCAT([DISTINCT] expr [ORDER BY ...] [SEPARATOR '...'])
+        """
+        return "GROUP_CONCAT(%s)" % self.function_argspec(fn, **kw)
+
+    def visit_cast(self, cast, **kw):
+        # https://www.cubrid.org/manual/en/11.0/sql/function/typecast_fn.html#cast
+        type_ = self.process(cast.typeclause)
+        if type_ is None:
+            return self.process(cast.clause.self_group())
+        return f"CAST({self.process(cast.clause)} AS {type_})"
+
+    def render_literal_value(self, value, type_):
+        value = super().render_literal_value(value, type_)
+        value = value.replace("\\", "\\\\")
+        return value
+
+    def get_select_precolumns(self, select, **kw):
+        if bool(select._distinct):
+            return "DISTINCT "
+        return ""
+
+    def visit_join(self, join, asfrom=False, **kwargs):
+        # https://www.cubrid.org/manual/en/11.0/sql/query/select.html#join-query
+        return "".join(
+            (
+                self.process(join.left, asfrom=True, **kwargs),
+                (join.isouter and " LEFT OUTER JOIN " or " INNER JOIN "),
+                self.process(join.right, asfrom=True, **kwargs),
+                " ON ",
+                self.process(join.onclause, **kwargs),
+            )
+        )
+
+    def for_update_clause(self, select, **kw):
+        """Render FOR UPDATE clause.
+
+        CUBRID supports::
+
+            SELECT ... FOR UPDATE
+            SELECT ... FOR UPDATE OF col1, col2
+
+        CUBRID does NOT support NOWAIT or SKIP LOCKED.
+        """
+        if select._for_update_arg is None:
+            return ""
+        text = " FOR UPDATE"
+        if select._for_update_arg.of:
+            text += " OF " + ", ".join(self.process(col, **kw) for col in select._for_update_arg.of)
+        return text
+
+    def limit_clause(self, select, **kw):
+        # https://www.cubrid.org/manual/en/11.0/sql/query/select.html#limit-clause
+        # SA 2.0: _limit_clause / _offset_clause are ClauseElements, not raw ints.
+        limit_clause = select._limit_clause
+        offset_clause = select._offset_clause
+        if limit_clause is None and offset_clause is None:
+            return ""
+        elif limit_clause is None and offset_clause is not None:
+            return " \n LIMIT %s, 1073741823" % (self.process(offset_clause, **kw),)
+        elif offset_clause is not None:
+            return " \n LIMIT %s, %s" % (
+                self.process(offset_clause, **kw),
+                self.process(limit_clause, **kw),
+            )
+        else:
+            return " \n LIMIT %s" % (self.process(limit_clause, **kw),)
+
+    def update_limit_clause(self, update_stmt):
+        # https://www.cubrid.org/manual/en/11.0/sql/query/update.html
+        limit = update_stmt.kwargs.get(f"{self.dialect.name}_limit", None)
+        if limit:
+            return f"LIMIT {limit}"
+        return None
+
+    def update_tables_clause(self, update_stmt, from_table, extra_froms, **kw):
+        return ", ".join(
+            t._compiler_dispatch(self, asfrom=True, **kw) for t in [from_table] + list(extra_froms)
+        )
+
+    def update_from_clause(self, update_stmt, from_table, extra_froms, from_hints, **kw):
+        return None
+
+    def visit_on_duplicate_key_update(self, on_duplicate, **kw):
+        """Render ON DUPLICATE KEY UPDATE clause.
+
+        CUBRID uses VALUES() function to reference inserted values,
+        identical to MySQL's pre-8.0 syntax.
+        """
+        from sqlalchemy.sql import coercions, elements, roles, visitors
+        from sqlalchemy.sql.expression import literal_column
+
+        statement = self.current_executable
+        table = getattr(statement, "table", None)
+        if table is None:
+            return "ON DUPLICATE KEY UPDATE"
+
+        if on_duplicate._parameter_ordering:
+            parameter_ordering = [
+                coercions.expect(roles.DMLColumnRole, key)
+                for key in on_duplicate._parameter_ordering
+            ]
+            ordered_keys = set(parameter_ordering)
+            cols = [table.c[key] for key in parameter_ordering if key in table.c] + [
+                c for c in table.c if c.key not in ordered_keys
+            ]
+        else:
+            cols = list(table.c)
+
+        clauses = []
+        on_duplicate_update = {
+            coercions.expect_as_key(roles.DMLColumnRole, key): value
+            for key, value in on_duplicate.update.items()
+        }
+
+        for column in (col for col in cols if col.key in on_duplicate_update):
+            val = on_duplicate_update[column.key]
+            if coercions._is_literal(val):
+                val = elements.BindParameter(None, val, type_=column.type)
+                value_text = self.process(val.self_group(), use_schema=False)
+            else:
+
+                def replace(element, captured_column=column, **kw):
+                    if isinstance(element, elements.BindParameter) and element.type._isnull:
+                        return element._with_binary_element_type(captured_column.type)
+                    elif (
+                        isinstance(element, elements.ColumnClause)
+                        and element.table is on_duplicate.inserted_alias
+                    ):
+                        return literal_column(f"VALUES({self.preparer.quote(element.name)})")
+                    else:
+                        return None
+
+                val = visitors.replacement_traverse(val, {}, replace)
+                value_text = self.process(val.self_group(), use_schema=False)
+
+            name_text = self.preparer.quote(column.name)
+            clauses.append(f"{name_text} = {value_text}")
+
+        non_matching = set(on_duplicate_update) - {c.key for c in cols}
+        if non_matching:
+            from sqlalchemy import util
+
+            table_name = getattr(table, "name", "<unknown>")
+            util.warn(
+                "Additional column names not matching "
+                "any column keys in table '%s': %s"
+                % (
+                    table_name,
+                    (", ".join("'%s'" % c for c in non_matching)),
+                )
+            )
+
+        return f"ON DUPLICATE KEY UPDATE {', '.join(clauses)}"
+
+    def visit_merge(self, merge_stmt, **kw):
+        from sqlalchemy import exc
+        from sqlalchemy.sql import coercions, elements
+
+        target = merge_stmt._target
+        source = merge_stmt._using_source
+        on_condition = merge_stmt._on_condition
+        when_matched = merge_stmt._when_matched
+        when_not_matched = merge_stmt._when_not_matched
+
+        if target is None:
+            raise exc.CompileError("MERGE statement requires a target table")
+        if source is None:
+            raise exc.CompileError("MERGE statement requires a USING source")
+        if on_condition is None:
+            raise exc.CompileError("MERGE statement requires an ON condition")
+        if when_matched is None and when_not_matched is None:
+            raise exc.CompileError(
+                "MERGE statement must include WHEN MATCHED and/or WHEN NOT MATCHED"
+            )
+
+        target_columns = getattr(target, "c", None)
+
+        def _resolve_target_column(column_key):
+            if isinstance(column_key, str):
+                if target_columns is not None and column_key in target_columns:
+                    return target_columns[column_key]
+                return None
+            if hasattr(column_key, "name"):
+                return column_key
+            return None
+
+        def _render_column_name(column_key):
+            if isinstance(column_key, str):
+                return self.preparer.quote(column_key)
+            if hasattr(column_key, "name"):
+                return self.preparer.quote(column_key.name)
+            return self.process(column_key, **kw)
+
+        def _render_value(value, target_column):
+            if coercions._is_literal(value):
+                value = elements.BindParameter(
+                    None,
+                    value,
+                    type_=getattr(target_column, "type", None),
+                )
+            return self.process(value.self_group(), use_schema=False, **kw)
+
+        lines = [
+            f"MERGE INTO {self.process(target, asfrom=True, **kw)}",
+            f"USING {self.process(source, asfrom=True, **kw)}",
+            f"ON ({self.process(on_condition, **kw)})",
+        ]
+
+        if when_matched is not None:
+            matched_values = when_matched.get("values") or {}
+            if not matched_values:
+                raise exc.CompileError(
+                    "MERGE WHEN MATCHED clause requires at least one UPDATE value"
+                )
+
+            set_clauses = []
+            for column_key, value in matched_values.items():
+                target_column = _resolve_target_column(column_key)
+                set_clauses.append(
+                    f"{_render_column_name(column_key)} = {_render_value(value, target_column)}"
+                )
+
+            matched_clause = f"WHEN MATCHED THEN UPDATE SET {', '.join(set_clauses)}"  # nosec B608
+            matched_where = when_matched.get("where")
+            if matched_where is not None:
+                matched_clause += f" WHERE {self.process(matched_where, **kw)}"
+
+            delete_where = when_matched.get("delete_where")
+            if delete_where is not None:
+                matched_clause += f" DELETE WHERE {self.process(delete_where, **kw)}"
+
+            lines.append(matched_clause)
+
+        if when_not_matched is not None:
+            insert_columns = when_not_matched.get("columns") or []
+            insert_values = when_not_matched.get("values") or []
+
+            if not insert_columns or not insert_values:
+                raise exc.CompileError(
+                    "MERGE WHEN NOT MATCHED clause requires INSERT columns and values"
+                )
+            if len(insert_columns) != len(insert_values):
+                raise exc.CompileError(
+                    "MERGE WHEN NOT MATCHED INSERT columns and values must match"
+                )
+
+            rendered_columns = []
+            rendered_values = []
+            for column_key, value in zip(insert_columns, insert_values):
+                target_column = _resolve_target_column(column_key)
+                rendered_columns.append(_render_column_name(column_key))
+                rendered_values.append(_render_value(value, target_column))
+
+            not_matched_clause = (
+                "WHEN NOT MATCHED THEN INSERT "
+                f"({', '.join(rendered_columns)}) "
+                f"VALUES ({', '.join(rendered_values)})"
+            )
+            insert_where = when_not_matched.get("where")
+            if insert_where is not None:
+                not_matched_clause += f" WHERE {self.process(insert_where, **kw)}"
+
+            lines.append(not_matched_clause)
+
+        return "\n".join(lines)
+
+    def visit_replace(self, replace_stmt, **kw):
+        text = super().visit_insert(replace_stmt, **kw)
+        if "INSERT INTO" in text:
+            return text.replace("INSERT INTO", "REPLACE INTO", 1)
+        if text.startswith("INSERT"):
+            return "REPLACE" + text[len("INSERT") :]
+        return text
+
+
+class CubridDDLCompiler(compiler.DDLCompiler):
+    """DDLCompiler subclass for CUBRID.
+
+    Handles AUTO_INCREMENT for autoincrement columns and column defaults.
+    """
+
+    def get_column_specification(self, column, **kw):
+        """Build column DDL specification.
+
+        CUBRID syntax::
+
+            column_name TYPE [NOT NULL] [AUTO_INCREMENT] [DEFAULT value]
+        """
+        colspec = [
+            self.preparer.format_column(column),
+            self.dialect.type_compiler_instance.process(column.type, type_expression=column),
+        ]
+
+        if not column.nullable:
+            colspec.append("NOT NULL")
+
+        if (
+            column.table is not None
+            and column is column.table._autoincrement_column
+            and (column.server_default is None)
+        ):
+            colspec.append("AUTO_INCREMENT")
+        else:
+            default = self.get_column_default_string(column)
+            if default is not None:
+                colspec.append("DEFAULT " + default)
+
+        if column.comment is not None:
+            literal = self.sql_compiler.render_literal_value(
+                column.comment,
+                sqltypes.String(),
+            )
+            colspec.append("COMMENT " + literal)
+
+        return " ".join(colspec)
+
+    def post_create_table(self, table):
+        table_opts = []
+        if table.comment is not None:
+            literal = self.sql_compiler.render_literal_value(
+                table.comment,
+                sqltypes.String(),
+            )
+            table_opts.append(f"\n COMMENT = {literal}")
+        return "".join(table_opts)
+
+    def visit_set_table_comment(self, create, **kw):
+        return "ALTER TABLE %s COMMENT = %s" % (
+            self.preparer.format_table(create.element),
+            self.sql_compiler.render_literal_value(
+                create.element.comment,
+                sqltypes.String(),
+            ),
+        )
+
+    def visit_drop_table_comment(self, drop, **kw):
+        return "ALTER TABLE %s COMMENT = ''" % (self.preparer.format_table(drop.element),)
+
+    def visit_set_column_comment(self, create, **kw):
+        return "ALTER TABLE %s MODIFY %s %s COMMENT %s" % (
+            self.preparer.format_table(create.element.table),
+            self.preparer.format_column(create.element),
+            self.dialect.type_compiler_instance.process(
+                create.element.type,
+                type_expression=create.element,
+            ),
+            self.sql_compiler.render_literal_value(
+                create.element.comment,
+                sqltypes.String(),
+            ),
+        )
+
+
+class CubridTypeCompiler(compiler.GenericTypeCompiler):
+    """TypeCompiler for CUBRID data types."""
+
+    def _get(self, key, type_, kw):
+        return kw.get(key, getattr(type_, key, None))
+
+    def visit_BOOLEAN(self, type_, **kw):
+        # CUBRID has no native BOOLEAN; map to SMALLINT.
+        return self.visit_SMALLINT(type_)
+
+    def visit_NUMERIC(self, type_, **kw):
+        if type_.precision is None:
+            return "NUMERIC"
+        elif type_.scale is None:
+            return f"NUMERIC({type_.precision})"
+        else:
+            return f"NUMERIC({type_.precision}, {type_.scale})"
+
+    def visit_DECIMAL(self, type_, **kw):
+        if type_.precision is None:
+            return "DECIMAL"
+        elif type_.scale is None:
+            return f"DECIMAL({type_.precision})"
+        else:
+            return f"DECIMAL({type_.precision}, {type_.scale})"
+
+    def visit_FLOAT(self, type_, **kw):
+        if type_.precision is None:
+            return "FLOAT"
+        else:
+            return f"FLOAT({type_.precision})"
+
+    def visit_DOUBLE(self, type_, **kw):
+        return "DOUBLE"
+
+    def visit_MONETARY(self, type_, **kw):
+        return "MONETARY"
+
+    def visit_SMALLINT(self, type_, **kw):
+        return "SMALLINT"
+
+    def visit_BIGINT(self, type_, **kw):
+        return "BIGINT"
+
+    def visit_BIT(self, type_, **kw):
+        if type_.varying:
+            compiled = "BIT VARYING"
+            if type_.length is not None:
+                compiled += f"({type_.length})"
+        else:
+            compiled = f"BIT({type_.length})"
+        return compiled
+
+    def visit_datetime(self, type_, **kw):
+        return "DATETIME"
+
+    def visit_DATETIME(self, type_, **kw):
+        return "DATETIME"
+
+    def visit_DATE(self, type_, **kw):
+        return "DATE"
+
+    def visit_TIME(self, type_, **kw):
+        return "TIME"
+
+    def visit_TIMESTAMP(self, type_, **kw):
+        return "TIMESTAMP"
+
+    def visit_VARCHAR(self, type_, **kw):
+        if hasattr(type_, "national") and type_.national:
+            return self.visit_NVARCHAR(type_)
+        elif type_.length:
+            return "VARCHAR(%d)" % type_.length
+        else:
+            return "VARCHAR(4096)"
+
+    def visit_CHAR(self, type_, **kw):
+        if hasattr(type_, "national") and type_.national:
+            return self.visit_NCHAR(type_)
+        elif type_.length:
+            return f"CHAR({type_.length})"
+        else:
+            return "CHAR"
+
+    def visit_NVARCHAR(self, type_, **kw):
+        if type_.length:
+            return f"NCHAR VARYING({type_.length})"
+        else:
+            return "NCHAR VARYING(4096)"
+
+    def visit_NCHAR(self, type_, **kw):
+        if type_.length:
+            return f"NCHAR({type_.length})"
+        else:
+            return "NCHAR"
+
+    def visit_OBJECT(self, type_, **kw):
+        return "OBJECT"
+
+    def visit_large_binary(self, type_, **kw):
+        return self.visit_BLOB(type_)
+
+    def visit_text(self, type_, **kw):
+        return self.visit_STRING(type_)
+
+    def visit_BLOB(self, type_, **kw):
+        return "BLOB"
+
+    def visit_CLOB(self, type_, **kw):
+        return "CLOB"
+
+    def visit_STRING(self, type_, **kw):
+        return "STRING"
+
+    def visit_SET(self, type_, **kw):
+        return self._visit_collection(type_, "SET")
+
+    def visit_MULTISET(self, type_, **kw):
+        return self._visit_collection(type_, "MULTISET")
+
+    def visit_SEQUENCE(self, type_, **kw):
+        return self._visit_collection(type_, "SEQUENCE")
+
+    def _visit_collection(self, type_, collection_type, **kw):
+        """Compile CUBRID collection types (SET, MULTISET, LIST/SEQUENCE).
+
+        See: https://www.cubrid.org/manual/en/11.0/sql/datatype.html#collection-types
+        """
+        parts = []
+        for value in type_._ddl_values:
+            if isinstance(value, str):
+                parts.append(value)
+            else:
+                parts.append(value.__visit_name__)
+        return f"{collection_type}({','.join(parts)})"