tsikol 0.1.0

data/docs/examples/database-manager.md

@@ -0,0 +1,1198 @@
+# Database Manager Example
+
+A comprehensive MCP server for database operations including queries, migrations, backups, and monitoring across multiple database systems.
+
+## Overview
+
+This example demonstrates:
+- Multi-database support (PostgreSQL, MySQL, SQLite)
+- Query execution and optimization
+- Database migrations
+- Backup and restore operations
+- Performance monitoring
+- Connection pooling
+- Transaction management
+
+## Implementation
+
+### server.rb
+
+```ruby
+#!/usr/bin/env ruby
+
+require 'tsikol'
+require 'sequel'
+require 'pg'
+require 'mysql2'
+require 'sqlite3'
+
+# Database connection manager
+class DatabaseManager
+  attr_reader :connections
+  
+  def initialize
+    @connections = {}
+    @pools = {}
+  end
+  
+  def add_connection(name, config)
+    adapter = config[:adapter] || 'postgres'
+    
+    connection_string = case adapter
+    when 'postgres', 'postgresql'
+      "postgres://#{config[:user]}:#{config[:password]}@#{config[:host]}:#{config[:port]}/#{config[:database]}"
+    when 'mysql', 'mysql2'
+      "mysql2://#{config[:user]}:#{config[:password]}@#{config[:host]}:#{config[:port]}/#{config[:database]}"
+    when 'sqlite'
+      "sqlite://#{config[:database]}"
+    end
+    
+    @connections[name] = Sequel.connect(
+      connection_string,
+      max_connections: config[:pool_size] || 5,
+      pool_timeout: config[:pool_timeout] || 5
+    )
+    
+    # Test connection
+    @connections[name].test_connection
+    
+    log :info, "Database connected", name: name, adapter: adapter
+  end
+  
+  def get_connection(name)
+    @connections[name] || raise("Unknown database: #{name}")
+  end
+  
+  def close_all
+    @connections.each do |name, db|
+      db.disconnect
+      log :info, "Database disconnected", name: name
+    end
+    @connections.clear
+  end
+end
+
+# Query execution tool
+class QueryTool < Tsikol::Tool
+  name "execute_query"
+  description "Execute SQL queries with safety checks"
+  
+  parameter :database do
+    type :string
+    required
+    description "Database connection name"
+    
+    complete do |partial|
+      @database_manager.connections.keys.select { |k| k.start_with?(partial) }
+    end
+  end
+  
+  parameter :query do
+    type :string
+    required
+    description "SQL query to execute"
+  end
+  
+  parameter :params do
+    type :array
+    optional
+    default []
+    description "Query parameters for prepared statements"
+  end
+  
+  parameter :limit do
+    type :number
+    optional
+    default 1000
+    description "Maximum number of rows to return"
+  end
+  
+  def execute(database:, query:, params: [], limit: 1000)
+    db = @database_manager.get_connection(database)
+    
+    # Safety checks
+    validate_query!(query)
+    
+    # Add limit if SELECT and no limit specified
+    query = add_limit_if_needed(query, limit)
+    
+    start_time = Time.now
+    
+    begin
+      if write_query?(query)
+        # Execute write query in transaction
+        result = db.transaction do
+          if params.any?
+            db[query, *params].all
+          else
+            db.run(query)
+          end
+        end
+        
+        rows_affected = result.is_a?(Integer) ? result : 0
+        format_write_result(query, rows_affected, Time.now - start_time)
+      else
+        # Execute read query
+        dataset = params.any? ? db[query, *params] : db[query]
+        rows = dataset.limit(limit).all
+        
+        format_query_result(rows, Time.now - start_time)
+      end
+    rescue Sequel::DatabaseError => e
+      log :error, "Query failed", error: e.message, query: query
+      "Query failed: #{e.message}"
+    end
+  end
+  
+  private
+  
+  def validate_query!(query)
+    # Basic SQL injection prevention
+    dangerous_patterns = [
+      /;\s*DROP\s+/i,
+      /;\s*DELETE\s+FROM\s+/i,
+      /;\s*TRUNCATE\s+/i,
+      /;\s*ALTER\s+/i
+    ]
+    
+    dangerous_patterns.each do |pattern|
+      if query.match?(pattern)
+        raise "Potentially dangerous query pattern detected"
+      end
+    end
+  end
+  
+  def write_query?(query)
+    query.match?(/^\s*(INSERT|UPDATE|DELETE|CREATE|DROP|ALTER|TRUNCATE)/i)
+  end
+  
+  def add_limit_if_needed(query, limit)
+    if query.match?(/^\s*SELECT/i) && !query.match?(/LIMIT\s+\d+/i)
+      "#{query.strip} LIMIT #{limit}"
+    else
+      query
+    end
+  end
+  
+  def format_query_result(rows, duration)
+    return "No results found. (#{(duration * 1000).round(2)}ms)" if rows.empty?
+    
+    # Get column names
+    columns = rows.first.keys
+    
+    # Calculate column widths
+    widths = columns.map do |col|
+      [col.to_s.length, *rows.map { |row| row[col].to_s.length }].max
+    end
+    
+    # Build table
+    lines = []
+    
+    # Header
+    header = columns.zip(widths).map { |col, width| col.to_s.ljust(width) }.join(" | ")
+    lines << header
+    lines << "-" * header.length
+    
+    # Rows
+    rows.each do |row|
+      line = columns.zip(widths).map { |col, width| row[col].to_s.ljust(width) }.join(" | ")
+      lines << line
+    end
+    
+    lines << ""
+    lines << "#{rows.count} rows returned (#{(duration * 1000).round(2)}ms)"
+    
+    lines.join("\n")
+  end
+  
+  def format_write_result(query, rows_affected, duration)
+    operation = query.split.first.upcase
+    "#{operation} completed: #{rows_affected} rows affected (#{(duration * 1000).round(2)}ms)"
+  end
+end
+
+# Schema information tool
+class SchemaTool < Tsikol::Tool
+  name "show_schema"
+  description "Display database schema information"
+  
+  parameter :database do
+    type :string
+    required
+    description "Database connection name"
+  end
+  
+  parameter :table do
+    type :string
+    optional
+    description "Specific table to inspect"
+    
+    complete do |partial|
+      db = @database_manager.get_connection(params[:database])
+      db.tables.select { |t| t.to_s.start_with?(partial) }.map(&:to_s)
+    end
+  end
+  
+  def execute(database:, table: nil)
+    db = @database_manager.get_connection(database)
+    
+    if table
+      show_table_schema(db, table.to_sym)
+    else
+      show_database_schema(db)
+    end
+  end
+  
+  private
+  
+  def show_database_schema(db)
+    tables = db.tables
+    
+    lines = ["Database Schema", "=" * 40, ""]
+    lines << "Tables (#{tables.count}):"
+    
+    tables.each do |table|
+      row_count = db[table].count
+      lines << "  #{table} (#{row_count} rows)"
+    end
+    
+    # Show views if any
+    if db.respond_to?(:views)
+      views = db.views
+      if views.any?
+        lines << ""
+        lines << "Views (#{views.count}):"
+        views.each { |view| lines << "  #{view}" }
+      end
+    end
+    
+    lines.join("\n")
+  end
+  
+  def show_table_schema(db, table)
+    unless db.table_exists?(table)
+      return "Table '#{table}' does not exist"
+    end
+    
+    schema = db.schema(table)
+    indexes = db.indexes(table)
+    foreign_keys = db.foreign_key_list(table)
+    
+    lines = ["Table: #{table}", "=" * 40, ""]
+    
+    # Columns
+    lines << "Columns:"
+    schema.each do |column, info|
+      type = info[:db_type]
+      nullable = info[:allow_null] ? "NULL" : "NOT NULL"
+      default = info[:default] ? " DEFAULT #{info[:default]}" : ""
+      primary = info[:primary_key] ? " PRIMARY KEY" : ""
+      
+      lines << "  #{column}: #{type} #{nullable}#{default}#{primary}"
+    end
+    
+    # Indexes
+    if indexes.any?
+      lines << ""
+      lines << "Indexes:"
+      indexes.each do |name, info|
+        columns = info[:columns].join(", ")
+        unique = info[:unique] ? "UNIQUE " : ""
+        lines << "  #{name}: #{unique}(#{columns})"
+      end
+    end
+    
+    # Foreign Keys
+    if foreign_keys.any?
+      lines << ""
+      lines << "Foreign Keys:"
+      foreign_keys.each do |fk|
+        lines << "  #{fk[:columns].join(", ")} -> #{fk[:table]}.#{fk[:key].join(", ")}"
+      end
+    end
+    
+    lines.join("\n")
+  end
+end
+
+# Migration tool
+class MigrationTool < Tsikol::Tool
+  name "run_migration"
+  description "Run database migrations"
+  
+  parameter :database do
+    type :string
+    required
+    description "Database connection name"
+  end
+  
+  parameter :direction do
+    type :string
+    required
+    enum ["up", "down"]
+    description "Migration direction"
+  end
+  
+  parameter :version do
+    type :number
+    optional
+    description "Specific version to migrate to"
+  end
+  
+  parameter :migration_dir do
+    type :string
+    optional
+    default "./migrations"
+    description "Directory containing migration files"
+  end
+  
+  def execute(database:, direction:, version: nil, migration_dir: "./migrations")
+    db = @database_manager.get_connection(database)
+    
+    # Create migrations table if needed
+    create_migrations_table(db)
+    
+    # Get migration files
+    migrations = load_migrations(migration_dir)
+    
+    if direction == "up"
+      run_migrations_up(db, migrations, version)
+    else
+      run_migrations_down(db, migrations, version)
+    end
+  end
+  
+  private
+  
+  def create_migrations_table(db)
+    db.create_table?(:schema_migrations) do
+      String :version, primary_key: true
+      DateTime :applied_at
+    end
+  end
+  
+  def load_migrations(dir)
+    return [] unless Dir.exist?(dir)
+    
+    Dir.glob("#{dir}/*.rb").map do |file|
+      version = File.basename(file).split('_').first.to_i
+      {
+        version: version,
+        file: file,
+        name: File.basename(file, '.rb')
+      }
+    end.sort_by { |m| m[:version] }
+  end
+  
+  def run_migrations_up(db, migrations, target_version)
+    applied = db[:schema_migrations].select_map(:version).map(&:to_i)
+    
+    to_apply = migrations.reject { |m| applied.include?(m[:version]) }
+    to_apply = to_apply.select { |m| m[:version] <= target_version } if target_version
+    
+    if to_apply.empty?
+      return "No migrations to apply"
+    end
+    
+    results = []
+    
+    to_apply.each do |migration|
+      begin
+        # Load and run migration
+        load migration[:file]
+        
+        migration_class = Object.const_get("Migration#{migration[:version]}")
+        migration_instance = migration_class.new(db)
+        
+        db.transaction do
+          migration_instance.up
+          db[:schema_migrations].insert(
+            version: migration[:version].to_s,
+            applied_at: Time.now
+          )
+        end
+        
+        results << "Applied: #{migration[:name]}"
+      rescue => e
+        results << "Failed: #{migration[:name]} - #{e.message}"
+        break
+      end
+    end
+    
+    results.join("\n")
+  end
+end
+
+# Backup tool
+class BackupTool < Tsikol::Tool
+  name "backup_database"
+  description "Create database backups"
+  
+  parameter :database do
+    type :string
+    required
+    description "Database to backup"
+  end
+  
+  parameter :format do
+    type :string
+    optional
+    default "sql"
+    enum ["sql", "csv", "json"]
+    description "Backup format"
+  end
+  
+  parameter :tables do
+    type :array
+    optional
+    description "Specific tables to backup (all if not specified)"
+  end
+  
+  parameter :output_dir do
+    type :string
+    optional
+    default "./backups"
+    description "Output directory for backup files"
+  end
+  
+  def execute(database:, format: "sql", tables: nil, output_dir: "./backups")
+    db = @database_manager.get_connection(database)
+    
+    # Create backup directory
+    FileUtils.mkdir_p(output_dir)
+    
+    # Generate backup filename
+    timestamp = Time.now.strftime("%Y%m%d_%H%M%S")
+    filename = "#{database}_#{timestamp}.#{format}"
+    filepath = File.join(output_dir, filename)
+    
+    # Get tables to backup
+    tables_to_backup = tables || db.tables.map(&:to_s)
+    
+    case format
+    when "sql"
+      backup_to_sql(db, filepath, tables_to_backup)
+    when "csv"
+      backup_to_csv(db, output_dir, timestamp, tables_to_backup)
+    when "json"
+      backup_to_json(db, filepath, tables_to_backup)
+    end
+  end
+  
+  private
+  
+  def backup_to_sql(db, filepath, tables)
+    File.open(filepath, 'w') do |file|
+      file.puts "-- Database backup generated at #{Time.now}"
+      file.puts "-- Tables: #{tables.join(', ')}"
+      file.puts
+      
+      tables.each do |table|
+        table_sym = table.to_sym
+        
+        # Table structure
+        file.puts "-- Table: #{table}"
+        file.puts generate_create_table(db, table_sym)
+        file.puts
+        
+        # Table data
+        db[table_sym].each do |row|
+          columns = row.keys.join(", ")
+          values = row.values.map { |v| quote_value(v) }.join(", ")
+          file.puts "INSERT INTO #{table} (#{columns}) VALUES (#{values});"
+        end
+        file.puts
+      end
+    end
+    
+    "Backup created: #{filepath}"
+  end
+  
+  def quote_value(value)
+    case value
+    when nil then "NULL"
+    when String then "'#{value.gsub("'", "''")}'"
+    when Time, DateTime then "'#{value.iso8601}'"
+    else value.to_s
+    end
+  end
+end
+
+# Performance monitoring resource
+class PerformanceResource < Tsikol::Resource
+  uri "database/:name/performance"
+  description "Database performance metrics"
+  
+  def read
+    database_name = params[:name]
+    db = @database_manager.get_connection(database_name)
+    
+    metrics = {
+      database: database_name,
+      timestamp: Time.now.iso8601,
+      connection_pool: get_pool_stats(db),
+      query_stats: get_query_stats(db),
+      table_sizes: get_table_sizes(db),
+      slow_queries: get_slow_queries(db)
+    }
+    
+    metrics.to_json
+  end
+  
+  private
+  
+  def get_pool_stats(db)
+    pool = db.pool
+    {
+      size: pool.size,
+      available: pool.available_connections,
+      allocated: pool.allocated,
+      waiting: pool.instance_variable_get(:@waiter)&.length || 0
+    }
+  end
+  
+  def get_query_stats(db)
+    # This would need database-specific implementation
+    {
+      total_queries: @query_count || 0,
+      average_duration_ms: @average_duration || 0,
+      cache_hit_rate: 0.85  # Mock value
+    }
+  end
+  
+  def get_table_sizes(db)
+    db.tables.map do |table|
+      {
+        name: table,
+        row_count: db[table].count,
+        estimated_size: estimate_table_size(db, table)
+      }
+    end.sort_by { |t| -t[:row_count] }.first(10)
+  end
+  
+  def estimate_table_size(db, table)
+    # Simple estimation based on row count and column count
+    row_count = db[table].count
+    col_count = db.schema(table).count
+    
+    # Assume average 100 bytes per cell
+    bytes = row_count * col_count * 100
+    
+    if bytes < 1024
+      "#{bytes} B"
+    elsif bytes < 1024 * 1024
+      "#{(bytes / 1024.0).round(2)} KB"
+    elsif bytes < 1024 * 1024 * 1024
+      "#{(bytes / (1024.0 * 1024)).round(2)} MB"
+    else
+      "#{(bytes / (1024.0 * 1024 * 1024)).round(2)} GB"
+    end
+  end
+end
+
+# Database health check resource
+class HealthCheckResource < Tsikol::Resource
+  uri "database/:name/health"
+  description "Database health status"
+  
+  def read
+    database_name = params[:name]
+    
+    health = {
+      database: database_name,
+      status: "unknown",
+      checks: {}
+    }
+    
+    begin
+      db = @database_manager.get_connection(database_name)
+      
+      # Connection check
+      health[:checks][:connection] = check_connection(db)
+      
+      # Disk space check
+      health[:checks][:disk_space] = check_disk_space
+      
+      # Replication check (if applicable)
+      health[:checks][:replication] = check_replication(db)
+      
+      # Overall status
+      health[:status] = determine_overall_status(health[:checks])
+      
+    rescue => e
+      health[:status] = "error"
+      health[:error] = e.message
+    end
+    
+    health.to_json
+  end
+  
+  private
+  
+  def check_connection(db)
+    start = Time.now
+    db.test_connection
+    latency = ((Time.now - start) * 1000).round(2)
+    
+    {
+      status: latency < 100 ? "healthy" : "degraded",
+      latency_ms: latency
+    }
+  end
+  
+  def check_disk_space
+    # Mock implementation
+    {
+      status: "healthy",
+      free_space: "42.5 GB",
+      usage_percent: 58
+    }
+  end
+  
+  def check_replication(db)
+    # Database-specific implementation needed
+    {
+      status: "healthy",
+      lag_seconds: 0.2
+    }
+  end
+  
+  def determine_overall_status(checks)
+    statuses = checks.values.map { |c| c[:status] }
+    
+    return "error" if statuses.include?("error")
+    return "degraded" if statuses.include?("degraded")
+    "healthy"
+  end
+end
+
+# Query optimizer prompt
+class QueryOptimizerPrompt < Tsikol::Prompt
+  name "query_optimizer"
+  description "SQL query optimization assistant"
+  
+  argument :database_type do
+    type :string
+    required
+    enum ["postgresql", "mysql", "sqlite"]
+    description "Type of database"
+  end
+  
+  argument :focus do
+    type :string
+    optional
+    default "performance"
+    enum ["performance", "readability", "maintainability"]
+    description "Optimization focus"
+  end
+  
+  def get_messages(database_type:, focus: "performance")
+    [
+      {
+        role: "system",
+        content: {
+          type: "text",
+          text: build_system_prompt(database_type, focus)
+        }
+      },
+      {
+        role: "user",
+        content: {
+          type: "text",
+          text: "Initialize query optimizer"
+        }
+      },
+      {
+        role: "assistant",
+        content: {
+          type: "text",
+          text: "I'm ready to help optimize your #{database_type} queries with a focus on #{focus}. I can analyze query execution plans, suggest indexes, rewrite queries for better performance, and explain optimization strategies. What query would you like me to help with?"
+        }
+      }
+    ]
+  end
+  
+  private
+  
+  def build_system_prompt(database_type, focus)
+    <<~PROMPT
+      You are an expert SQL query optimizer specializing in #{database_type}.
+      
+      Focus: #{focus}
+      
+      Key capabilities:
+      1. Analyze and explain query execution plans
+      2. Suggest optimal indexes
+      3. Rewrite queries for better performance
+      4. Identify and fix common performance issues
+      5. Provide database-specific optimizations
+      
+      Guidelines for #{database_type}:
+      #{database_specific_guidelines(database_type)}
+      
+      Always consider:
+      - Index usage and selectivity
+      - Join order and methods
+      - Subquery optimization
+      - Proper use of database-specific features
+      - Query caching opportunities
+      - Lock contention and concurrency
+    PROMPT
+  end
+  
+  def database_specific_guidelines(type)
+    case type
+    when "postgresql"
+      "- Use EXPLAIN ANALYZE for accurate timings\n- Consider partial indexes\n- Leverage JSONB for semi-structured data\n- Use CTEs wisely (materialized vs not)\n- Consider parallel query execution"
+    when "mysql"
+      "- Check storage engine implications\n- Use covering indexes\n- Be aware of query cache\n- Optimize for InnoDB\n- Consider partitioning for large tables"
+    when "sqlite"
+      "- Remember single-writer limitation\n- Use appropriate journal modes\n- Consider memory vs disk trade-offs\n- Optimize for embedded use cases\n- Use EXPLAIN QUERY PLAN"
+    end
+  end
+end
+
+# Initialize and start server
+database_manager = DatabaseManager.new
+
+# Configure databases from environment or config
+if ENV['DATABASE_URL']
+  database_manager.add_connection('default', {
+    adapter: 'postgres',
+    url: ENV['DATABASE_URL']
+  })
+end
+
+Tsikol.start(
+  name: "database-manager",
+  version: "1.0.0",
+  description: "Comprehensive database management MCP server"
+) do
+  # Enable capabilities
+  logging true
+  prompts true
+  completion true
+  
+  # Share database manager
+  before_start do
+    @database_manager = database_manager
+  end
+  
+  # Cleanup on stop
+  before_stop do
+    @database_manager.close_all
+  end
+  
+  # Middleware
+  use Tsikol::LoggingMiddleware, level: :info
+  use Tsikol::AuthenticationMiddleware,
+      type: :bearer,
+      validator: ->(token) { validate_db_token(token) }
+  
+  # Tools
+  tool QueryTool
+  tool SchemaTool
+  tool MigrationTool
+  tool BackupTool
+  
+  # Resources
+  resource PerformanceResource
+  resource HealthCheckResource
+  
+  # Prompts
+  prompt QueryOptimizerPrompt
+  
+  # Add dynamic database configuration
+  tool "add_database" do
+    parameter :name do
+      type :string
+      required
+      description "Connection name"
+    end
+    
+    parameter :config do
+      type :object
+      required
+      description "Database configuration"
+    end
+    
+    def execute(name:, config:)
+      @database_manager.add_connection(name, config)
+      "Database '#{name}' connected successfully"
+    rescue => e
+      "Failed to connect: #{e.message}"
+    end
+  end
+  
+  # List databases
+  resource "databases" do
+    description "List configured databases"
+    
+    def read
+      databases = @database_manager.connections.map do |name, db|
+        {
+          name: name,
+          connected: db.test_connection rescue false,
+          tables: db.tables.count rescue 0
+        }
+      end
+      
+      { databases: databases }.to_json
+    end
+  end
+  
+  def validate_db_token(token)
+    # In production, validate against user database
+    return { user_id: "admin", permissions: ["read", "write"] } if token == "admin-token"
+    return { user_id: "readonly", permissions: ["read"] } if token == "readonly-token"
+    nil
+  end
+end
+```
+
+### Migration Example
+
+```ruby
+# migrations/001_create_users.rb
+class Migration001 < Sequel::Migration
+  def up
+    create_table :users do
+      primary_key :id
+      String :email, null: false, unique: true
+      String :name
+      String :password_digest, null: false
+      DateTime :created_at, null: false
+      DateTime :updated_at, null: false
+      
+      index :email
+      index :created_at
+    end
+  end
+  
+  def down
+    drop_table :users
+  end
+end
+
+# migrations/002_create_posts.rb
+class Migration002 < Sequel::Migration
+  def up
+    create_table :posts do
+      primary_key :id
+      foreign_key :user_id, :users, null: false, on_delete: :cascade
+      String :title, null: false
+      Text :content
+      String :status, default: 'draft'
+      DateTime :published_at
+      DateTime :created_at, null: false
+      DateTime :updated_at, null: false
+      
+      index :user_id
+      index :status
+      index :published_at
+      index [:user_id, :status]
+    end
+  end
+  
+  def down
+    drop_table :posts
+  end
+end
+```
+
+### Configuration
+
+```yaml
+# config/databases.yml
+development:
+  default:
+    adapter: postgresql
+    host: localhost
+    port: 5432
+    database: myapp_development
+    user: postgres
+    password: postgres
+    pool_size: 5
+    
+  analytics:
+    adapter: postgresql
+    host: localhost
+    port: 5432
+    database: myapp_analytics
+    user: postgres
+    password: postgres
+    pool_size: 3
+    
+  cache:
+    adapter: sqlite
+    database: ./db/cache.db
+
+production:
+  default:
+    adapter: postgresql
+    url: ${DATABASE_URL}
+    pool_size: ${DB_POOL_SIZE:20}
+    
+  read_replica:
+    adapter: postgresql
+    url: ${READ_REPLICA_URL}
+    pool_size: ${DB_POOL_SIZE:20}
+```
+
+### Testing
+
+```ruby
+require 'minitest/autorun'
+require 'tsikol/test_helpers'
+
+class DatabaseManagerTest < Minitest::Test
+  include Tsikol::TestHelpers
+  
+  def setup
+    @server = create_test_server
+    @client = TestClient.new(@server)
+    setup_test_database
+  end
+  
+  def teardown
+    cleanup_test_database
+  end
+  
+  def test_query_execution
+    # Insert test data
+    @client.call_tool("execute_query", {
+      "database" => "test",
+      "query" => "INSERT INTO users (name, email) VALUES (?, ?)",
+      "params" => ["John Doe", "john@example.com"]
+    })
+    
+    # Query data
+    response = @client.call_tool("execute_query", {
+      "database" => "test",
+      "query" => "SELECT * FROM users WHERE email = ?",
+      "params" => ["john@example.com"]
+    })
+    
+    assert_successful_response(response)
+    result = response.dig(:result, :content, 0, :text)
+    assert_match /John Doe/, result
+  end
+  
+  def test_schema_information
+    response = @client.call_tool("show_schema", {
+      "database" => "test",
+      "table" => "users"
+    })
+    
+    assert_successful_response(response)
+    result = response.dig(:result, :content, 0, :text)
+    assert_match /name: text/, result
+    assert_match /email: text/, result
+  end
+  
+  def test_backup_creation
+    response = @client.call_tool("backup_database", {
+      "database" => "test",
+      "format" => "sql"
+    })
+    
+    assert_successful_response(response)
+    result = response.dig(:result, :content, 0, :text)
+    assert_match /Backup created/, result
+    
+    # Check backup file exists
+    backup_files = Dir.glob("./backups/test_*.sql")
+    assert backup_files.any?
+  end
+  
+  def test_query_safety
+    # Test dangerous query detection
+    response = @client.call_tool("execute_query", {
+      "database" => "test",
+      "query" => "SELECT * FROM users; DROP TABLE users;"
+    })
+    
+    assert_successful_response(response)
+    result = response.dig(:result, :content, 0, :text)
+    assert_match /dangerous query pattern/, result
+  end
+  
+  def test_performance_metrics
+    response = @client.read_resource("database/test/performance")
+    
+    assert_successful_response(response)
+    metrics = JSON.parse(response.dig(:result, :contents, 0, :text))
+    
+    assert metrics["connection_pool"]
+    assert metrics["table_sizes"]
+  end
+  
+  private
+  
+  def create_test_server
+    manager = DatabaseManager.new
+    manager.add_connection("test", {
+      adapter: "sqlite",
+      database: ":memory:"
+    })
+    
+    Tsikol::Server.new(name: "test-db-manager") do
+      before_start { @database_manager = manager }
+      
+      tool QueryTool
+      tool SchemaTool
+      tool BackupTool
+      resource PerformanceResource
+    end
+  end
+  
+  def setup_test_database
+    db = @server.instance_variable_get(:@database_manager).get_connection("test")
+    
+    db.create_table :users do
+      primary_key :id
+      String :name
+      String :email
+    end
+    
+    db.create_table :posts do
+      primary_key :id
+      foreign_key :user_id, :users
+      String :title
+      Text :content
+    end
+  end
+  
+  def cleanup_test_database
+    FileUtils.rm_rf("./backups")
+  end
+end
+```
+
+## Advanced Features
+
+### Query Analysis and Optimization
+
+```ruby
+class QueryAnalyzer
+  def analyze(query, database_type)
+    analysis = {
+      query: query,
+      type: detect_query_type(query),
+      tables: extract_tables(query),
+      joins: analyze_joins(query),
+      filters: analyze_filters(query),
+      suggestions: []
+    }
+    
+    # Add optimization suggestions
+    if missing_index?(analysis)
+      analysis[:suggestions] << {
+        type: "index",
+        message: "Consider adding index on filter columns",
+        columns: analysis[:filters].map { |f| f[:column] }
+      }
+    end
+    
+    if inefficient_join?(analysis)
+      analysis[:suggestions] << {
+        type: "join",
+        message: "Consider reordering joins for better performance"
+      }
+    end
+    
+    analysis
+  end
+  
+  private
+  
+  def detect_query_type(query)
+    case query
+    when /^\s*SELECT/i then :select
+    when /^\s*INSERT/i then :insert
+    when /^\s*UPDATE/i then :update
+    when /^\s*DELETE/i then :delete
+    else :other
+    end
+  end
+  
+  def extract_tables(query)
+    # Simple regex-based extraction
+    query.scan(/(?:FROM|JOIN)\s+(\w+)/i).flatten.uniq
+  end
+end
+```
+
+### Connection Pool Monitoring
+
+```ruby
+class PoolMonitor
+  def initialize(database_manager)
+    @database_manager = database_manager
+    @metrics = Concurrent::Hash.new
+    start_monitoring
+  end
+  
+  def start_monitoring
+    Thread.new do
+      loop do
+        @database_manager.connections.each do |name, db|
+          pool = db.pool
+          
+          @metrics[name] = {
+            size: pool.size,
+            available: pool.available_connections,
+            allocated: pool.allocated,
+            max_size: pool.max_size,
+            wait_timeout: pool.connection_timeout
+          }
+        end
+        
+        sleep 5
+      end
+    end
+  end
+  
+  def get_metrics
+    @metrics.to_h
+  end
+end
+```
+
+## Best Practices Demonstrated
+
+1. **Connection Pooling** - Efficient database connection management
+2. **Prepared Statements** - SQL injection prevention
+3. **Transaction Management** - Data consistency
+4. **Query Optimization** - Performance monitoring and analysis
+5. **Backup Strategies** - Multiple format support
+6. **Migration System** - Version-controlled schema changes
+7. **Health Monitoring** - Proactive issue detection
+8. **Multi-Database Support** - Flexible architecture
+9. **Security** - Authentication and query validation
+10. **Resource Management** - Proper cleanup and connection handling
+
+## Performance Optimization
+
+1. **Query Caching** - Cache frequently used queries
+2. **Index Management** - Automatic index suggestions
+3. **Connection Pooling** - Reuse database connections
+4. **Batch Operations** - Process multiple operations together
+5. **Async Processing** - Non-blocking database operations
+
+## Security Considerations
+
+1. **SQL Injection Prevention** - Parameterized queries
+2. **Access Control** - Role-based permissions
+3. **Audit Logging** - Track all database operations
+4. **Encryption** - Secure sensitive data
+5. **Connection Security** - SSL/TLS for database connections
+
+## Next Steps
+
+- Add support for NoSQL databases
+- Implement query plan visualization
+- Add real-time replication monitoring
+- Create database migration UI
+- Add automatic backup scheduling
+- Implement query result caching