MindsDB 25.3.4.1__py3-none-any.whl → 25.3.4.2__py3-none-any.whl

mindsdb/integrations/handlers/mssql_handler/mssql_handler.py

@@ -13,10 +13,43 @@ from mindsdb.integrations.libs.response import (
     HandlerResponse as Response,
     RESPONSE_TYPE
 )
+from mindsdb.api.mysql.mysql_proxy.libs.constants.mysql import MYSQL_DATA_TYPE
+
 
 logger = log.getLogger(__name__)
 
 
+def _map_type(mssql_type_text: str) -> MYSQL_DATA_TYPE:
+    """ Map MSSQL text types names to MySQL types as enum.
+
+    Args:
+        mssql_type_text (str): The name of the MSSQL type to map.
+
+    Returns:
+        MYSQL_DATA_TYPE: The MySQL type enum that corresponds to the MSSQL text type name.
+    """
+    internal_type_name = mssql_type_text.lower()
+    types_map = {
+        ('tinyint', 'smallint', 'int', 'bigint'): MYSQL_DATA_TYPE.INT,
+        ('bit',): MYSQL_DATA_TYPE.BOOL,
+        ('money', 'smallmoney', 'float', 'real'): MYSQL_DATA_TYPE.FLOAT,
+        ('decimal', 'numeric'): MYSQL_DATA_TYPE.DECIMAL,
+        ('date',): MYSQL_DATA_TYPE.DATE,
+        ('time',): MYSQL_DATA_TYPE.TIME,
+        ('datetime2', 'datetimeoffset', 'datetime', 'smalldatetime'): MYSQL_DATA_TYPE.DATETIME,
+        ('varchar', 'nvarchar'): MYSQL_DATA_TYPE.VARCHAR,
+        ('char', 'text', 'nchar', 'ntext'): MYSQL_DATA_TYPE.TEXT,
+        ('binary', 'varbinary', 'image'): MYSQL_DATA_TYPE.BINARY
+    }
+
+    for db_types_list, mysql_data_type in types_map.items():
+        if internal_type_name in db_types_list:
+            return mysql_data_type
+
+    logger.warning(f"MSSQL handler type mapping: unknown type: {internal_type_name}, use VARCHAR as fallback.")
+    return MYSQL_DATA_TYPE.VARCHAR
+
+
 class SqlServerHandler(DatabaseHandler):
     """
     This handler handles connection and execution of the Microsoft SQL Server statements.
@@ -215,4 +248,7 @@ class SqlServerHandler(DatabaseHandler):
             WHERE
                 table_name = '{table_name}'
         """
-        return self.native_query(query)
+        result = self.native_query(query)
+        if result.resp_type is RESPONSE_TYPE.TABLE:
+            result.data_frame['mysql_data_type'] = result.data_frame['Type'].apply(_map_type)
+        return result

mindsdb/integrations/handlers/mysql_handler/mysql_handler.py

@@ -13,10 +13,27 @@ from mindsdb.integrations.libs.response import (
     RESPONSE_TYPE
 )
 from mindsdb.integrations.handlers.mysql_handler.settings import ConnectionConfig
+from mindsdb.api.mysql.mysql_proxy.libs.constants.mysql import MYSQL_DATA_TYPE
 
 logger = log.getLogger(__name__)
 
 
+def _map_type(mysql_type_text: str) -> MYSQL_DATA_TYPE:
+    """ Map MySQL text types names to MySQL types as enum.
+
+    Args:
+        mysql_type_text (str): The name of the MySQL type to map.
+
+    Returns:
+        MYSQL_DATA_TYPE: The MySQL type enum that corresponds to the MySQL text type name.
+    """
+    try:
+        return MYSQL_DATA_TYPE(mysql_type_text.upper())
+    except Exception:
+        logger.warning(f'MySQL handler: unknown type: {mysql_type_text}, use TEXT as fallback.')
+        return MYSQL_DATA_TYPE.TEXT
+
+
 class MySQLHandler(DatabaseHandler):
     """
     This handler handles connection and execution of the MySQL statements.
@@ -211,6 +228,16 @@ class MySQLHandler(DatabaseHandler):
         """
         Show details about the table
         """
-        q = f"DESCRIBE `{table_name}`;"
+        q = f"""
+            select
+                COLUMN_NAME AS FIELD, DATA_TYPE AS TYPE
+            from
+                information_schema.columns
+            where
+                table_name = '{table_name}'
+        """
         result = self.native_query(q)
+        if result.resp_type is RESPONSE_TYPE.TABLE:
+            result.data_frame = result.data_frame.rename(columns={'FIELD': 'Field', 'TYPE': 'Type'})
+            result.data_frame['mysql_data_type'] = result.data_frame['Type'].apply(_map_type)
         return result

mindsdb/integrations/handlers/oracle_handler/oracle_handler.py

@@ -1,10 +1,9 @@
 from typing import Text, Dict, Optional
 
-from mindsdb_sql_parser.ast.base import ASTNode
-from mindsdb.utilities.render.sqlalchemy_render import SqlalchemyRender
 import oracledb
-from oracledb import connect, Connection, DatabaseError
 import pandas as pd
+from oracledb import connect, Connection, DatabaseError
+from mindsdb_sql_parser.ast.base import ASTNode
 
 from mindsdb.integrations.libs.base import DatabaseHandler
 from mindsdb.integrations.libs.response import (
@@ -13,12 +12,52 @@ from mindsdb.integrations.libs.response import (
     RESPONSE_TYPE,
 )
 from mindsdb.utilities import log
+from mindsdb.utilities.render.sqlalchemy_render import SqlalchemyRender
+from mindsdb.api.mysql.mysql_proxy.libs.constants.mysql import MYSQL_DATA_TYPE
 
 
 oracledb.defaults.fetch_lobs = False  # Return LOBs directly as strings or bytes.
 logger = log.getLogger(__name__)
 
 
+def _map_type(internal_type_name: str) -> MYSQL_DATA_TYPE:
+    """ Map Oracle types to MySQL types.
+        List of types: https://docs.oracle.com/en/database/oracle/oracle-database/19/sqlrf/Data-Types.html
+
+    Args:
+        internal_type_name (str): The name of the Oracle type to map.
+
+    Returns:
+        MYSQL_DATA_TYPE: The MySQL type that corresponds to the Oracle type.
+    """
+    internal_type_name = internal_type_name.upper()
+    types_map = {
+        (
+            'VARCHAR2', 'NVARCHAR2', 'CHARACTER VARYING', 'CHAR VARYING', 'NATIONAL CHARACTER', 'NATIONAL CHAR',
+            'VARCHAR', 'NCHAR', 'NATIONAL CHARACTER VARYING', 'NATIONAL CHAR VARYING', 'NCHAR VARYING', 'LONG VARCHAR'
+        ): MYSQL_DATA_TYPE.VARCHAR,
+        ('INTEGER', 'INT'): MYSQL_DATA_TYPE.INT,
+        ('SMALLINT',): MYSQL_DATA_TYPE.SMALLINT,
+        ('NUMBER', 'DECIMAL'): MYSQL_DATA_TYPE.DECIMAL,
+        ('FLOAT', 'BINARY_FLOAT', 'REAL'): MYSQL_DATA_TYPE.FLOAT,
+        ('BINARY_DOUBLE',): MYSQL_DATA_TYPE.DOUBLE,
+        ('LONG',): MYSQL_DATA_TYPE.BIGINT,
+        ('DATE',): MYSQL_DATA_TYPE.DATE,
+        ('HOUR', 'MINUTE', 'SECOND', 'TIMEZONE_HOUR', 'TIMEZONE_MINUTE'): MYSQL_DATA_TYPE.SMALLINT,
+        ('TIMESTAMP', 'TIMESTAMP WITH TIME ZONE', 'TIMESTAMP WITH LOCAL TIME ZONE'): MYSQL_DATA_TYPE.TIMESTAMP,
+        ('RAW', 'LONG RAW', 'BLOB', 'BFILE'): MYSQL_DATA_TYPE.BINARY,
+        ('ROWID', 'UROWID'): MYSQL_DATA_TYPE.TEXT,
+        ('CHAR', 'NCHAR', 'CLOB', 'NCLOB', 'CHARACTER'): MYSQL_DATA_TYPE.CHAR,
+    }
+
+    for db_types_list, mysql_data_type in types_map.items():
+        if internal_type_name in db_types_list:
+            return mysql_data_type
+
+    logger.warning(f"Oracle handler type mapping: unknown type: {internal_type_name}, use VARCHAR as fallback.")
+    return MYSQL_DATA_TYPE.VARCHAR
+
+
 class OracleHandler(DatabaseHandler):
     """
     This handler handles connection and execution of SQL queries on Oracle.
@@ -94,6 +133,12 @@ class OracleHandler(DatabaseHandler):
             connection = connect(
                 **config,
             )
+
+            if 'session_variables' in self.connection_data:
+                with connection.cursor() as cur:
+                    for key, value in self.connection_data['session_variables'].items():
+                        cur.execute(f"ALTER SESSION SET {key} = {repr(value)}")
+
         except DatabaseError as database_error:
             logger.error(f'Error connecting to Oracle, {database_error}!')
             raise
@@ -237,10 +282,13 @@ class OracleHandler(DatabaseHandler):
         """
         query = f"""
             SELECT
-                column_name,
-                data_type
+                column_name AS field,
+                data_type AS type
             FROM USER_TAB_COLUMNS
             WHERE table_name = '{table_name}'
         """
         result = self.native_query(query)
+        if result.resp_type is RESPONSE_TYPE.TABLE:
+            result.data_frame.columns = [name.lower() for name in result.data_frame.columns]
+            result.data_frame['mysql_data_type'] = result.data_frame['type'].apply(_map_type)
         return result

mindsdb/integrations/handlers/postgres_handler/postgres_handler.py

@@ -20,12 +20,44 @@ from mindsdb.integrations.libs.response import (
     RESPONSE_TYPE
 )
 import mindsdb.utilities.profiler as profiler
+from mindsdb.api.mysql.mysql_proxy.libs.constants.mysql import MYSQL_DATA_TYPE
 
 logger = log.getLogger(__name__)
 
 SUBSCRIBE_SLEEP_INTERVAL = 1
 
 
+def _map_type(internal_type_name: str) -> MYSQL_DATA_TYPE:
+    """Map Postgres types to MySQL types.
+
+    Args:
+        internal_type_name (str): The name of the Postgres type to map.
+
+    Returns:
+        MYSQL_DATA_TYPE: The MySQL type that corresponds to the Postgres type.
+    """
+    internal_type_name = internal_type_name.lower()
+    types_map = {
+        ('smallint', 'integer', 'bigint', 'int', 'smallserial', 'serial', 'bigserial'): MYSQL_DATA_TYPE.INT,
+        ('real', 'money', 'float'): MYSQL_DATA_TYPE.FLOAT,
+        ('numeric', 'decimal'): MYSQL_DATA_TYPE.DECIMAL,
+        ('double precision',): MYSQL_DATA_TYPE.DOUBLE,
+        ('character varying', 'varchar', 'character', 'char', 'bpchar', 'bpchar', 'text'): MYSQL_DATA_TYPE.TEXT,
+        ('timestamp', 'timestamp without time zone', 'timestamp with time zone'): MYSQL_DATA_TYPE.DATETIME,
+        ('date', ): MYSQL_DATA_TYPE.DATE,
+        ('time', 'time without time zone', 'time with time zone'): MYSQL_DATA_TYPE.TIME,
+        ('boolean',): MYSQL_DATA_TYPE.BOOL,
+        ('bytea',): MYSQL_DATA_TYPE.BINARY,
+    }
+
+    for db_types_list, mysql_data_type in types_map.items():
+        if internal_type_name in db_types_list:
+            return mysql_data_type
+
+    logger.warning(f"Postgres handler type mapping: unknown type: {internal_type_name}, use VARCHAR as fallback.")
+    return MYSQL_DATA_TYPE.VARCHAR
+
+
 class PostgresHandler(DatabaseHandler):
     """
     This handler handles connection and execution of the PostgreSQL statements.
@@ -314,7 +346,11 @@ class PostgresHandler(DatabaseHandler):
             AND
                 table_schema = {schema_name}
         """
-        return self.native_query(query)
+        result = self.native_query(query)
+        if result.resp_type is RESPONSE_TYPE.TABLE:
+            result.data_frame.columns = [name.lower() for name in result.data_frame.columns]
+            result.data_frame['mysql_data_type'] = result.data_frame['type'].apply(_map_type)
+        return result
 
     def subscribe(self, stop_event, callback, table_name, columns=None, **kwargs):
         config = self._make_connection_args()

mindsdb/integrations/handlers/snowflake_handler/snowflake_handler.py

@@ -16,6 +16,7 @@ from mindsdb.integrations.libs.response import (
     HandlerResponse as Response,
     RESPONSE_TYPE
 )
+from mindsdb.api.mysql.mysql_proxy.libs.constants.mysql import MYSQL_DATA_TYPE
 
 try:
     import pyarrow as pa
@@ -27,6 +28,43 @@ except Exception:
 logger = log.getLogger(__name__)
 
 
+def _map_type(internal_type_name: str) -> MYSQL_DATA_TYPE:
+    """ Map Snowflake types to MySQL types.
+
+    Args:
+        internal_type_name (str): The name of the Snowflake type to map.
+
+    Returns:
+        MYSQL_DATA_TYPE: The MySQL type that corresponds to the Snowflake type.
+    """
+    internal_type_name = internal_type_name.upper()
+    types_map = {
+        ('NUMBER', 'DECIMAL', 'DEC', 'NUMERIC'): MYSQL_DATA_TYPE.DECIMAL,
+        ('INT , INTEGER , BIGINT , SMALLINT , TINYINT , BYTEINT'): MYSQL_DATA_TYPE.INT,
+        ('FLOAT', 'FLOAT4', 'FLOAT8'): MYSQL_DATA_TYPE.FLOAT,
+        ('DOUBLE', 'DOUBLE PRECISION', 'REAL'): MYSQL_DATA_TYPE.DOUBLE,
+        ('VARCHAR'): MYSQL_DATA_TYPE.VARCHAR,
+        ('CHAR', 'CHARACTER', 'NCHAR'): MYSQL_DATA_TYPE.CHAR,
+        ('STRING', 'TEXT', 'NVARCHAR'): MYSQL_DATA_TYPE.TEXT,
+        ('NVARCHAR2', 'CHAR VARYING', 'NCHAR VARYING'): MYSQL_DATA_TYPE.VARCHAR,
+        ('BINARY', 'VARBINARY'): MYSQL_DATA_TYPE.BINARY,
+        ('BOOLEAN',): MYSQL_DATA_TYPE.BOOL,
+        ('TIMESTAMP_NTZ', 'DATETIME'): MYSQL_DATA_TYPE.DATETIME,
+        ('DATE',): MYSQL_DATA_TYPE.DATE,
+        ('TIME',): MYSQL_DATA_TYPE.TIME,
+        ('TIMESTAMP_LTZ'): MYSQL_DATA_TYPE.DATETIME,
+        ('TIMESTAMP_TZ'): MYSQL_DATA_TYPE.DATETIME,
+        ('VARIANT', 'OBJECT', 'ARRAY', 'MAP', 'GEOGRAPHY', 'GEOMETRY', 'VECTOR'): MYSQL_DATA_TYPE.VARCHAR
+    }
+
+    for db_types_list, mysql_data_type in types_map.items():
+        if internal_type_name in db_types_list:
+            return mysql_data_type
+
+    logger.warning(f"Snowflake handler type mapping: unknown type: {internal_type_name}, use VARCHAR as fallback.")
+    return MYSQL_DATA_TYPE.VARCHAR
+
+
 class SnowflakeHandler(DatabaseHandler):
     """
     This handler handles connection and execution of the Snowflake statements.
@@ -286,6 +324,7 @@ class SnowflakeHandler(DatabaseHandler):
 
         Returns:
             Response: A response object containing the column details, formatted as per the `Response` class.
+
         Raises:
             ValueError: If the 'table_name' is not a valid string.
         """
@@ -300,6 +339,8 @@ class SnowflakeHandler(DatabaseHandler):
               AND TABLE_SCHEMA = current_schema()
         """
         result = self.native_query(query)
-        result.data_frame = result.data_frame.rename(columns={'FIELD': 'Field', 'TYPE': 'Type'})
+        if result.resp_type is RESPONSE_TYPE.TABLE:
+            result.data_frame = result.data_frame.rename(columns={'FIELD': 'Field', 'TYPE': 'Type'})
+            result.data_frame['mysql_data_type'] = result.data_frame['Type'].apply(_map_type)
 
         return result

mindsdb/integrations/utilities/handlers/auth_utilities/__init__.py

@@ -1,2 +1,2 @@
 from .google import GoogleUserOAuth2Manager, GoogleServiceAccountOAuth2Manager
-from .microsoft import MSGraphAPIDelegatedPermissionsManager
+from .microsoft import MSGraphAPIApplicationPermissionsManager, MSGraphAPIDelegatedPermissionsManager

mindsdb/integrations/utilities/handlers/auth_utilities/microsoft/__init__.py

@@ -1 +1 @@
-from .ms_graph_api_auth_utilities import MSGraphAPIDelegatedPermissionsManager
+from .ms_graph_api_auth_utilities import MSGraphAPIApplicationPermissionsManager, MSGraphAPIDelegatedPermissionsManager

mindsdb/integrations/utilities/handlers/auth_utilities/microsoft/ms_graph_api_auth_utilities.py

@@ -1,3 +1,4 @@
+from abc import ABC, abstractmethod
 from typing import Dict, List, Text
 
 from flask import request
@@ -6,12 +7,13 @@ import msal
 from mindsdb.integrations.utilities.handlers.auth_utilities.exceptions import AuthException
 from mindsdb.utilities import log
 
+
 logger = log.getLogger(__name__)
 
 
-class MSGraphAPIDelegatedPermissionsManager:
+class MSGraphAPIPermissionsManager(ABC):
     """
-    The class for managing the delegated permissions for the Microsoft Graph API.
+    The base class for managing the delegated permissions for the Microsoft Graph API.
     """
     def __init__(
         self,
@@ -20,10 +22,9 @@ class MSGraphAPIDelegatedPermissionsManager:
         tenant_id: Text,
         cache: msal.SerializableTokenCache,
         scopes: List = ["https://graph.microsoft.com/.default"],
-        code: Text = None,
     ) -> None:
         """
-        Initializes the delegated permissions manager.
+        Initializes the permissions manager.
 
         Args:
             client_id (Text): The client ID of the application registered in Microsoft Entra ID.
@@ -38,8 +39,68 @@ class MSGraphAPIDelegatedPermissionsManager:
         self.tenant_id = tenant_id
         self.cache = cache
         self.scopes = scopes
+
+    @abstractmethod
+    def get_access_token(self) -> Text:
+        """
+        Retrieves an access token for the Microsoft Graph API.
+
+        Returns:
+            Text: The access token for the Microsoft Graph API.
+        """
+        pass
+
+    def _get_msal_app(self) -> msal.ConfidentialClientApplication:
+        """
+        Returns an instance of the MSAL ConfidentialClientApplication.
+
+        Returns:
+            msal.ConfidentialClientApplication: An instance of the MSAL ConfidentialClientApplication.
+        """
+        return msal.ConfidentialClientApplication(
+            self.client_id,
+            authority=f"https://login.microsoftonline.com/{self.tenant_id}",
+            client_credential=self.client_secret,
+            token_cache=self.cache,
+        )
+
+
+class MSGraphAPIDelegatedPermissionsManager(MSGraphAPIPermissionsManager):
+    """
+    The class for managing the delegated permissions for the Microsoft Graph API.
+    """
+    def __init__(
+        self,
+        client_id: Text,
+        client_secret: Text,
+        tenant_id: Text,
+        cache: msal.SerializableTokenCache,
+        scopes: List = ["https://graph.microsoft.com/.default"],
+        code: Text = None,
+    ) -> None:
+        """
+        Initializes the delegated permissions manager.
+
+        Args:
+            client_id (Text): The client ID of the application registered in Microsoft Entra ID.
+            client_secret (Text): The client secret of the application registered in Microsoft Entra ID.
+            tenant_id (Text): The tenant ID of the application registered in Microsoft Entra ID.
+            cache (msal.SerializableTokenCache): The token cache for storing the access token.
+            scopes (List): The scopes for the Microsoft Graph API.
+            code (Text): The authentication code for acquiring the access token.
+        """
+        super().__init__(client_id, client_secret, tenant_id, cache, scopes)
         self.code = code
+        self.redirect_uri = None
+        self._set_redirect_uri()
+
+    def _set_redirect_uri(self) -> None:
+        """
+        Sets the redirect URI based on the request origin.
 
+        Raises:
+            AuthException: If the request origin could not be determined.
+        """
         # Set the redirect URI based on the request origin.
         # If the request origin is 127.0.0.1 (localhost), replace it with localhost.
         # This is done because the only HTTP origin allowed in Microsoft Entra ID app registration is localhost.
@@ -85,20 +146,6 @@ class MSGraphAPIDelegatedPermissionsManager:
                 auth_url=response.get('auth_url')
             )
 
-    def _get_msal_app(self) -> msal.ConfidentialClientApplication:
-        """
-        Returns an instance of the MSAL ConfidentialClientApplication.
-
-        Returns:
-            msal.ConfidentialClientApplication: An instance of the MSAL ConfidentialClientApplication.
-        """
-        return msal.ConfidentialClientApplication(
-            self.client_id,
-            authority=f"https://login.microsoftonline.com/{self.tenant_id}",
-            client_credential=self.client_secret,
-            token_cache=self.cache,
-        )
-
     def _execute_ms_graph_api_auth_flow(self) -> Dict:
         """
         Executes the authentication flow for the Microsoft Graph API.
@@ -131,3 +178,35 @@ class MSGraphAPIDelegatedPermissionsManager:
             )
 
             raise AuthException(f'Authorisation required. Please follow the url: {auth_url}', auth_url=auth_url)
+
+
+class MSGraphAPIApplicationPermissionsManager(MSGraphAPIPermissionsManager):
+    """
+    The class for managing application permissions for the Microsoft Graph API.
+    """
+
+    def get_access_token(self) -> Text:
+        """
+        Retrieves an access token for the Microsoft Graph API using the client credentials flow.
+
+        Returns:
+            Text: The access token for the Microsoft Graph API.
+        """
+        msal_app = self._get_msal_app()
+
+        # Check if a valid access token is already in the cache.
+        accounts = msal_app.get_accounts()
+        if accounts:
+            response = msal_app.acquire_token_silent(self.scopes, account=accounts[0])
+            if "access_token" in response:
+                return response["access_token"]
+
+        # If no valid access token is found in the cache, acquire a new token using client credentials.
+        response = msal_app.acquire_token_for_client(scopes=self.scopes)
+
+        if "access_token" in response:
+            return response["access_token"]
+        else:
+            raise AuthException(
+                f"Error getting access token: {response.get('error_description')}"
+            )

mindsdb/utilities/render/sqlalchemy_render.py

@@ -27,6 +27,7 @@ types_map = {}
 for type_name in sa_type_names:
     types_map[type_name.upper()] = getattr(sa.types, type_name)
 types_map['BOOL'] = types_map['BOOLEAN']
+types_map['DEC'] = types_map['DECIMAL']
 
 
 class RenderError(Exception):
@@ -43,6 +44,11 @@ class INTERVAL(ColumnElement):
 @compiles(INTERVAL)
 def _compile_interval(element, compiler, **kw):
     items = element.info.split(' ', maxsplit=1)
+    if compiler.dialect.name == 'oracle' and len(items) == 2:
+        # replace to singular names (remove leading S if exists)
+        if items[1].upper().endswith('S'):
+            items[1] = items[1][:-1]
+
     if compiler.dialect.driver in ['snowflake']:
         # quote all
         args = " ".join(map(str, items))
@@ -118,6 +124,8 @@ class SqlalchemyRender:
         self.dialect = dialect(paramstyle="named")
         self.dialect.div_is_floordiv = False
 
+        self.selects_stack = []
+
         if dialect_name == 'mssql':
             # update version to MS_2008_VERSION for supports_multivalues_insert
             self.dialect.server_version_info = (10,)
@@ -143,8 +151,10 @@ class SqlalchemyRender:
                 part = self.dialect.identifier_preparer.quote(i)
 
             parts2.append(part)
-
-        return sa.column('.'.join(parts2), is_literal=True)
+        text = '.'.join(parts2)
+        if identifier.is_outer and self.dialect.name == 'oracle':
+            text += '(+)'
+        return sa.column(text, is_literal=True)
 
     def get_alias(self, alias):
         if alias is None or len(alias.parts) == 0:
@@ -152,6 +162,9 @@ class SqlalchemyRender:
         if len(alias.parts) > 1:
             raise NotImplementedError(f'Multiple alias {alias.parts}')
 
+        if self.selects_stack:
+            self.selects_stack[-1]['aliases'].append(alias)
+
         is_quoted = get_is_quoted(alias)[0]
         return AttributedStr(alias.parts[0], is_quoted)
 
@@ -205,12 +218,18 @@ class SqlalchemyRender:
                 alias = self.get_alias(t.alias)
                 col = col.label(alias)
         elif isinstance(t, ast.Function):
-            fnc = self.to_function(t)
+            col = self.to_function(t)
             if t.alias:
                 alias = self.get_alias(t.alias)
+                col = col.label(alias)
             else:
                 alias = str(t.op)
-            col = fnc.label(alias)
+                if self.selects_stack:
+                    aliases = self.selects_stack[-1]['aliases']
+                    if alias not in aliases:
+                        aliases.append(alias)
+                        col = col.label(alias)
+
         elif isinstance(t, ast.BinaryOperation):
             ops = {
                 "+": operators.add,
@@ -432,9 +451,9 @@ class SqlalchemyRender:
             return typename
 
         typename = typename.upper()
-        if re.match(r'^INT[\d]*$', typename):
+        if re.match(r'^INT[\d]+$', typename):
             typename = 'BIGINT'
-        if re.match(r'^FLOAT[\d]*$', typename):
+        if re.match(r'^FLOAT[\d]+$', typename):
             typename = 'FLOAT'
 
         return types_map[typename]
@@ -513,6 +532,9 @@ class SqlalchemyRender:
             return self.prepare_union(node)
 
         cols = []
+
+        self.selects_stack.append({'aliases': []})
+
         for t in node.targets:
             col = self.to_expression(t)
             cols.append(col)
@@ -647,6 +669,8 @@ class SqlalchemyRender:
             else:
                 raise NotImplementedError(f'Select mode: {node.mode}')
 
+        self.selects_stack.pop()
+
         return query
 
     def prepare_union(self, from_table):