# Projeto completo

Author: Bulletdev

.idea/.gitignore

@@ -0,0 +1,18 @@
+MIT License
+Copyright (c) 2024 Michael Bullet (michaelbullet.com)
+LinkedIn: https://www.linkedin.com/in/michael-bullet/
+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.

.idea/aws.xml

@@ -0,0 +1,52 @@
+# Database configurations
+databases:
+  mysql:
+    pool_size: 5
+    max_overflow: 10
+    pool_timeout: 30
+    pool_recycle: 3600
+
+  oracle:
+    pool_size: 5
+    max_overflow: 10
+    pool_timeout: 30
+    pool_recycle: 3600
+
+  postgresql:
+    pool_size: 5
+    max_overflow: 10
+    pool_timeout: 30
+    pool_recycle: 3600
+
+  mssql:
+    pool_size: 5
+    max_overflow: 10
+    pool_timeout: 30
+    pool_recycle: 3600
+
+# Logging configuration
+logging:
+  version: 1
+  formatters:
+    default:
+      format: '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+  handlers:
+    console:
+      class: logging.StreamHandler
+      formatter: default
+      level: INFO
+    file:
+      class: logging.FileHandler
+      formatter: default
+      filename: 'logs/app.log'
+      level: DEBUG
+  root:
+    level: INFO
+    handlers: [console, file]
+
+# API configuration
+api:
+  host: '0.0.0.0'
+  port: 5000
+  debug: true
+  secret_key: 'your-secret-key-here'  # Mude isso em produção

.idea/misc.xml

@@ -0,0 +1,14 @@
+Flask==3.0.0
+SQLAlchemy==2.0.25
+PyMySQL==1.1.0
+psycopg2-binary==2.9.9
+cx-Oracle==8.3.0
+pyodbc==5.0.1
+python-dotenv==1.0.0
+PyYAML==6.0.1
+marshmallow==3.20.1
+marshmallow-dataclass==8.6.0
+pytest==7.4.4
+black==23.12.1
+flake8==7.0.0
+mypy==1.8.0

.idea/modules.xml

@@ -0,0 +1 @@
+'''Arquivo de inicialização do backend'''

.idea/sql-query-builder.iml

@@ -0,0 +1,78 @@
+from flask import Flask, request, jsonify
+from datetime import datetime
+import time
+import logging.config
+import yaml
+from database.manager import DatabaseManager
+from database.models import QueryConfig, QueryResult
+from query.builder import QueryBuilder
+
+# Configuração do app
+app = Flask(__name__)
+db_manager = DatabaseManager('config.yml')
+
+# Configuração de logging
+with open('config.yml', 'r') as f:
+    config = yaml.safe_load(f)
+    logging.config.dictConfig(config['logging'])
+
+logger = logging.getLogger(__name__)
+
+@app.route('/health', methods=['GET'])
+def health_check():
+    """Endpoint para verificação de saúde da API."""
+    return jsonify({
+        'status': 'healthy',
+        'timestamp': datetime.now().isoformat()
+    })
+
+@app.route('/query', methods=['POST'])
+def execute_query():
+    """Endpoint principal para execução de queries."""
+    try:
+        start_time = time.time()
+        
+        # Valida e cria configuração
+        config = QueryConfig(**request.json)
+        config.validate()
+
+        # Obtém conexão e executa query
+        with db_manager.get_connection(
+            config.db_type, config.user, config.password, 
+            config.host, config.db_name
+        ) as connection:
+            # Obtém metadados e constrói query
+            metadata = db_manager.get_metadata(connection)
+            query_builder = QueryBuilder(metadata)
+            query = query_builder.build_query(config)
+
+            # Executa query e processa resultados
+            result = connection.execute(query)
+            data = [dict(row) for row in result]
+
+            # Cria resultado
+            execution_time = time.time() - start_time
+            query_result = QueryResult(
+                success=True,
+                data=data,
+                query=str(query),
+                execution_time=execution_time,
+                total_rows=len(data)
+            )
+
+            return jsonify(query_result.__dict__)
+
+    except Exception as e:
+        logger.error(f"Erro ao executar query: {str(e)}")
+        return jsonify({
+            'success': False,
+            'error': str(e.__class__.__name__),
+            'details': str(e)
+        }), 500
+
+if __name__ == '__main__':
+    app.run(
+        host=config['api']['host'],
+        port=config['api']['port'],
+        debug=config['api']['debug']
+    )

.idea/vcs.xml

@@ -0,0 +1,35 @@
+from sqlalchemy import create_engine
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.orm import sessionmaker
+import os
+
+# Create base class for declarative models
+Base = declarative_base()
+
+def get_database_url():
+    """Get database URL from environment variables or use default"""
+    host = os.getenv('DB_HOST', 'localhost')
+    port = os.getenv('DB_PORT', '5432')
+    name = os.getenv('DB_NAME', 'myapp')
+    user = os.getenv('DB_USER', 'user')
+    password = os.getenv('DB_PASSWORD', '')
+    
+    return f"postgresql://{user}:{password}@{host}:{port}/{name}"
+
+# Create database engine
+engine = create_engine(get_database_url())
+
+# Create sessionmaker
+SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+
+def get_db():
+    """Dependency to get database session"""
+    db = SessionLocal()
+    try:
+        yield db
+    finally:
+        db.close()
+
+def init_db():
+    """Initialize database tables"""
+    Base.metadata.create_all(bind=engine)

LICENSE

@@ -0,0 +1,78 @@
+from typing import Dict, Optional
+from sqlalchemy import create_engine, MetaData
+from sqlalchemy.engine import Engine
+from sqlalchemy.exc import SQLAlchemyError
+from contextlib import contextmanager
+import logging
+import yaml
+
+logger = logging.getLogger(__name__)
+
+class DatabaseManager:
+    """Gerencia conexões com diferentes tipos de bancos de dados."""
+    
+    SUPPORTED_DBS = {
+        'mysql': 'mysql+pymysql',
+        'postgresql': 'postgresql',
+        'oracle': 'oracle+cx_oracle',
+        'mssql': 'mssql+pyodbc'
+    }
+
+    def __init__(self, config_path: str = 'config.yml'):
+        self.engines: Dict[str, Engine] = {}
+        self.config = self._load_config(config_path)
+        
+    def _load_config(self, config_path: str) -> dict:
+        """Carrega configurações do arquivo YAML."""
+        try:
+            with open(config_path, 'r') as f:
+                return yaml.safe_load(f)
+        except Exception as e:
+            logger.error(f"Erro ao carregar configuração: {e}")
+            raise
+
+    def get_engine(self, db_type: str, user: str, password: str, 
+                   host: str, db_name: str) -> Engine:
+        """Obtém ou cria uma engine SQLAlchemy para o banco especificado."""
+        if db_type not in self.SUPPORTED_DBS:
+            raise ValueError(f"Banco de dados não suportado: {db_type}")
+
+        connection_key = f"{db_type}://{user}@{host}/{db_name}"
+        
+        if connection_key not in self.engines:
+            db_config = self.config['databases'].get(db_type, {})
+            connection_string = (
+                f"{self.SUPPORTED_DBS[db_type]}://"
+                f"{user}:{password}@{host}/{db_name}"
+            )
+            
+            self.engines[connection_key] = create_engine(
+                connection_string,
+                pool_size=db_config.get('pool_size', 5),
+                max_overflow=db_config.get('max_overflow', 10),
+                pool_timeout=db_config.get('pool_timeout', 30),
+                pool_recycle=db_config.get('pool_recycle', 3600)
+            )
+            
+        return self.engines[connection_key]
+
+    @contextmanager
+    def get_connection(self, db_type: str, user: str, password: str, 
+                      host: str, db_name: str):
+        """Context manager para obter uma conexão do pool."""
+        engine = self.get_engine(db_type, user, password, host, db_name)
+        try:
+            connection = engine.connect()
+            yield connection
+        finally:
+            connection.close()
+
+    def get_metadata(self, engine: Engine) -> MetaData:
+        """Obtém metadados das tabelas do banco de dados."""
+        metadata = MetaData()
+        try:
+            metadata.reflect(bind=engine)
+            return metadata
+        except SQLAlchemyError as e:
+            logger.error(f"Erro ao obter metadados: {e}")
+            raise