oracle-mcp-v1
Version:
Servidor MCP completo para Oracle Database com operações DDL, DML, DCL, monitoramento e auditoria
464 lines (377 loc) • 9.81 kB
Markdown
# Exemplos de Metadados - Oracle Node MCP Server
Este documento contém exemplos específicos para as ferramentas de metadados e administração do Oracle.
## 🔍 Consultas de Metadados
### 1. Informações Completas de uma Tabela
```json
{
"name": "get_table_info",
"arguments": {
"tableName": "EMPLOYEES",
"schema": "HR",
"includeConstraints": true,
"includeIndexes": true
}
}
```
**Resultado:**
- Informações básicas (tablespace, linhas, blocos)
- Estrutura das colunas com tipos e constraints
- Constraints (PK, FK, UNIQUE, CHECK)
- Índices com estatísticas
### 2. Análise de Constraints por Tipo
```json
{
"name": "get_constraints",
"arguments": {
"schema": "HR",
"constraintType": "FOREIGN KEY"
}
}
```
**Resultado:**
- Lista todas as foreign keys do esquema
- Mostra tabelas referenciadas
- Inclui condições de constraint
### 3. Mapeamento de Chaves Estrangeiras
```json
{
"name": "get_foreign_keys",
"arguments": {
"tableName": "EMPLOYEES",
"schema": "HR",
"showReferenced": true
}
}
```
**Resultado:**
- Mapeamento coluna → coluna referenciada
- Tabelas de destino das referências
- Estrutura hierárquica das dependências
## 📊 Análise de Performance
### 1. Índices com Estatísticas Detalhadas
```json
{
"name": "get_indexes",
"arguments": {
"tableName": "EMPLOYEES",
"schema": "HR",
"includeStats": true
}
}
```
**Métricas Incluídas:**
- Número de linhas indexadas
- Blocos folha utilizados
- Chaves distintas
- Data da última análise
- Status de validade
### 2. Análise de Tabela para Otimização
```json
{
"name": "analyze_table",
"arguments": {
"tableName": "EMPLOYEES",
"schema": "HR",
"estimatePercent": 20
}
}
```
**Benefícios:**
- Atualiza estatísticas do otimizador
- Melhora performance de queries
- Permite análise de amostra
- Gera métricas de tamanho
## 🔗 Análise de Dependências
### 1. Dependências Completas
```json
{
"name": "get_table_dependencies",
"arguments": {
"tableName": "EMPLOYEES",
"schema": "HR",
"dependencyType": "ALL"
}
}
```
**Mostra:**
- Objetos que dependem da tabela
- Objetos que a tabela referencia
- Tipos de dependência (VIEW, TRIGGER, etc.)
### 2. Apenas Objetos Dependentes
```json
{
"name": "get_table_dependencies",
"arguments": {
"tableName": "EMPLOYEES",
"schema": "HR",
"dependencyType": "DEPENDENTS"
}
}
```
**Útil para:**
- Verificar impacto de mudanças
- Identificar objetos afetados por DROP
- Planejar migrações
## 🔐 Administração de Usuários
### 1. Informações Completas de Usuário
```json
{
"name": "get_users_privileges",
"arguments": {
"user": "HR",
"includeRoles": true,
"includeSystemPrivs": true
}
}
```
**Inclui:**
- Status da conta
- Tablespaces padrão e temporário
- Roles atribuídos
- Privilégios de sistema
- Opções de administração
### 2. Lista Todos os Usuários
```json
{
"name": "get_users_privileges",
"arguments": {
"includeRoles": true,
"includeSystemPrivs": false
}
}
```
**Filtra:**
- Usuários do sistema (SYS, SYSTEM)
- Mostra apenas usuários de aplicação
- Inclui roles básicos
## 🔄 Sequences e Triggers
### 1. Sequences com Valores Atuais
```json
{
"name": "get_sequences",
"arguments": {
"schema": "HR",
"includeValues": true
}
}
```
**Informações:**
- Valores mínimo e máximo
- Incremento configurado
- Próximo valor a ser gerado
- Configurações de cache e ciclo
### 2. Triggers com Código
```json
{
"name": "get_triggers",
"arguments": {
"tableName": "EMPLOYEES",
"schema": "HR",
"includeCode": true
}
}
```
**Inclui:**
- Tipo de trigger (BEFORE/AFTER)
- Eventos que disparam (INSERT/UPDATE/DELETE)
- Condições WHEN
- Código PL/SQL completo
## 🛠️ Casos de Uso Práticos
### 1. Auditoria de Estrutura
```javascript
// Script para auditar estrutura completa de um esquema
const auditSchema = async (schema) => {
const tools = [
{ name: 'get_constraints', args: { schema } },
{ name: 'get_foreign_keys', args: { schema } },
{ name: 'get_indexes', args: { schema, includeStats: true } },
{ name: 'get_sequences', args: { schema, includeValues: true } },
{ name: 'get_triggers', args: { schema } }
];
for (const tool of tools) {
const result = await executeTool(tool.name, tool.args);
console.log(`\n=== ${tool.name.toUpperCase()} ===`);
console.log(result);
}
};
```
### 2. Análise de Performance
```javascript
// Script para análise de performance de tabelas
const analyzePerformance = async (tables) => {
for (const table of tables) {
// Analisar tabela
await executeTool('analyze_table', {
tableName: table.name,
schema: table.schema,
estimatePercent: 10
});
// Verificar índices
const indexes = await executeTool('get_indexes', {
tableName: table.name,
schema: table.schema,
includeStats: true
});
// Verificar dependências
const deps = await executeTool('get_table_dependencies', {
tableName: table.name,
schema: table.schema
});
console.log(`Análise completa para ${table.schema}.${table.name}`);
}
};
```
### 3. Validação de Integridade
```javascript
// Script para validar integridade referencial
const validateIntegrity = async (schema) => {
// Obter todas as foreign keys
const fks = await executeTool('get_foreign_keys', {
schema,
showReferenced: true
});
// Verificar constraints
const constraints = await executeTool('get_constraints', {
schema,
constraintType: 'FOREIGN KEY'
});
// Validar cada foreign key
for (const fk of fks) {
const query = `
SELECT COUNT(*) as orphan_count
FROM ${schema}.${fk.table_name} t
WHERE NOT EXISTS (
SELECT 1 FROM ${fk.ref_schema}.${fk.ref_table} r
WHERE t.${fk.column} = r.${fk.ref_column}
)
`;
const result = await executeTool('execute_safe_query', {
query,
schema
});
if (result.orphan_count > 0) {
console.warn(`⚠️ Orfãos encontrados em ${fk.table_name}.${fk.column}`);
}
}
};
```
### 4. Documentação Automática
```javascript
// Script para gerar documentação de esquema
const generateDocumentation = async (schema) => {
const tables = await getTablesInSchema(schema);
for (const table of tables) {
const info = await executeTool('get_table_info', {
tableName: table,
schema,
includeConstraints: true,
includeIndexes: true
});
const deps = await executeTool('get_table_dependencies', {
tableName: table,
schema
});
// Gerar documentação em Markdown
const doc = `
# Tabela ${table}
${info}
## Dependências
${deps}
`;
await saveDocumentation(`${schema}_${table}.md`, doc);
}
};
```
## 📈 Monitoramento de Mudanças
### 1. Detecção de Mudanças Estruturais
```javascript
// Script para detectar mudanças em constraints
const detectConstraintChanges = async (schema) => {
const currentConstraints = await executeTool('get_constraints', {
schema,
constraintType: 'ALL'
});
// Comparar com snapshot anterior
const previousConstraints = await loadSnapshot('constraints.json');
const changes = compareConstraints(currentConstraints, previousConstraints);
if (changes.length > 0) {
await sendAlert('CONSTRAINT_CHANGE', {
schema,
changes,
timestamp: new Date().toISOString()
});
}
};
```
### 2. Monitoramento de Performance
```javascript
// Script para monitorar performance de índices
const monitorIndexPerformance = async (schema) => {
const indexes = await executeTool('get_indexes', {
schema,
includeStats: true
});
for (const index of indexes) {
// Verificar se índice está sendo usado
const usageQuery = `
SELECT COUNT(*) as usage_count
FROM v$object_usage
WHERE index_name = '${index.name}'
AND used = 'YES'
`;
const usage = await executeTool('execute_safe_query', {
query: usageQuery,
schema
});
if (usage.usage_count === 0) {
console.warn(`⚠️ Índice ${index.name} não está sendo usado`);
}
}
};
```
## 🔧 Troubleshooting
### 1. Identificar Problemas de Performance
```json
{
"name": "get_indexes",
"arguments": {
"schema": "HR",
"includeStats": true
}
}
```
**Procurar por:**
- Índices com muitas linhas mas poucas chaves distintas
- Índices não analisados recentemente
- Índices em tablespaces com pouco espaço
### 2. Verificar Integridade Referencial
```json
{
"name": "get_foreign_keys",
"arguments": {
"schema": "HR",
"showReferenced": true
}
}
```
**Verificar:**
- Tabelas referenciadas existem
- Colunas referenciadas existem
- Tipos de dados são compatíveis
### 3. Analisar Dependências para Migração
```json
{
"name": "get_table_dependencies",
"arguments": {
"tableName": "EMPLOYEES",
"schema": "HR",
"dependencyType": "ALL"
}
}
```
**Considerar:**
- Ordem de criação/remoção
- Objetos dependentes
- Impacto de mudanças
---
**💡 Dica:** Use essas ferramentas em conjunto para obter uma visão completa da estrutura e performance do seu banco Oracle!