Wzorce i strategie NoSQL

Wzorce i strategie NoSQL

Wykorzystaj asystentów kodowania AI do projektowania, implementacji i optymalizacji rozwiązań baz danych NoSQL w magazynach dokumentów, kluczy-wartości i bazach grafowych.

Rozwój NoSQL wspomagany przez AI

Asystenci kodowania AI wyróżniają się w rozwoju NoSQL dzięki zrozumieniu wzorców bez schematu, sugerowaniu optymalnych modeli danych i generowaniu złożonych potoków agregacji. Dowiedz się, jak wykorzystać te możliwości do budowania skalowalnych, elastycznych rozwiązań bazodanowych.

Wzorce magazynów dokumentów (MongoDB, DynamoDB)

Projektowanie schematów ze wspomaganiem AI

Modelowanie dokumentów wspomagane przez AI

Wzorzec: Użyj AI do projektowania elastycznych schematów dokumentów, które równoważą denormalizację z spójnością danych.

// Zapytanie do asystenta AI
"Zaprojektuj schemat MongoDB dla platformy e-commerce z:
- Profilami użytkowników z adresami i metodami płatności
- Katalogiem produktów z wariantami i inwentarzem
- Zamówieniami ze śledzeniem statusu w czasie rzeczywistym
- Koszykiem z zarządzaniem sesją
Rozważ wzorce odczytu/zapisu i kompromisy denormalizacji"

// AI generuje kompleksowy schemat:
// Kolekcja użytkowników z dokumentami osadzonymi
const userSchema = {
  _id: ObjectId(),
  email: "user@example.com",
  profile: {
    firstName: "Jan",
    lastName: "Kowalski",
    phone: "+48123456789"
  },
  addresses: [
    {
      _id: ObjectId(),
      type: "shipping",
      street: "ul. Główna 123",
      city: "Warszawa",
      country: "Polska",
      isDefault: true
    }
  ],
  paymentMethods: [
    {
      _id: ObjectId(),
      type: "card",
      last4: "1234",
      expiryMonth: 12,
      expiryYear: 2025,
      isDefault: true
    }
  ],
  cart: {
    items: [
      {
        productId: ObjectId(),
        variantId: ObjectId(),
        quantity: 2,
        price: 29.99,
        addedAt: ISODate()
      }
    ],
    updatedAt: ISODate()
  }
};

// Kolekcja produktów z bogatymi atrybutami
const productSchema = {
  _id: ObjectId(),
  sku: "PROD-001",
  name: "Słuchawki bezprzewodowe",
  slug: "sluchawki-bezprzewodowe-czarne",
  description: "Słuchawki premium z redukcją szumów",
  category: ["Elektronika", "Audio", "Słuchawki"],

  // Zdenormalizowane dla wydajności
  brand: {
    _id: ObjectId(),
    name: "AudioTech",
    logo: "https://..."
  },

  // Warianty jako poddokumenty
  variants: [
    {
      _id: ObjectId(),
      color: "Czarny",
      price: 299.99,
      compareAtPrice: 349.99,
      inventory: {
        available: 150,
        reserved: 10,
        warehouse: {
          "WAW": 50,
          "KRK": 100
        }
      },
      images: ["url1", "url2"]
    }
  ],

  // Zagregowane dane recenzji
  reviews: {
    count: 245,
    average: 4.5,
    distribution: {
      5: 150,
      4: 60,
      3: 20,
      2: 10,
      1: 5
    }
  }
};

Korzyści:

• Zoptymalizowane pod operacje ciężkie odczytowo
• Minimalizuje złączenia poprzez strategiczną denormalizację
• Wspiera atomowe aktualizacje dokumentów osadzonych
• Skaluje się poziomo dzięki shardingowi

Opanowanie potoków agregacji

Złożone analityki

// Poproś AI o wygenerowanie potoku agregacji
"Utwórz potok agregacji MongoDB do:
1. Obliczenia miesięcznych przychodów według kategorii
2. Uwzględnienia wzrostu rok do roku
3. Filtrowania tylko aktywnych produktów
4. Sortowania według przychodów malejąco"

// AI generuje zoptymalizowany potok:
const pipeline = [
  {
    $match: {
      status: "active",
      "orders.createdAt": {
        $gte: ISODate("2024-01-01"),
        $lt: ISODate("2025-01-01")
      }
    }
  },
  {
    $unwind: "$orders"
  },
  {
    $group: {
      _id: {
        category: "$category",
        month: { $month: "$orders.createdAt" },
        year: { $year: "$orders.createdAt" }
      },
      revenue: { $sum: "$orders.total" },
      orderCount: { $sum: 1 }
    }
  },
  {
    $lookup: {
      from: "orders",
      let: {
        category: "$_id.category",
        prevYear: { $subtract: ["$_id.year", 1] },
        month: "$_id.month"
      },
      pipeline: [
        {
          $match: {
            $expr: {
              $and: [
                { $eq: ["$category", "$$category"] },
                { $eq: [{ $year: "$createdAt" }, "$$prevYear"] },
                { $eq: [{ $month: "$createdAt" }, "$$month"] }
              ]
            }
          }
        },
        {
          $group: {
            _id: null,
            prevRevenue: { $sum: "$total" }
          }
        }
      ],
      as: "previousYear"
    }
  },
  {
    $addFields: {
      yoyGrowth: {
        $cond: {
          if: { $gt: [{ $size: "$previousYear" }, 0] },
          then: {
            $multiply: [
              {
                $divide: [
                  { $subtract: ["$revenue", { $first: "$previousYear.prevRevenue" }] },
                  { $first: "$previousYear.prevRevenue" }
                ]
              },
              100
            ]
          },
          else: null
        }
      }
    }
  },
  {
    $sort: { revenue: -1 }
  }
];

Analityki czasu rzeczywistego

// Przetwarzanie strumieni zmian wspomagane przez AI
"Wygeneruj obsługę strumienia zmian MongoDB dla:
- Aktualizacji inwentarza w czasie rzeczywistym
- Powiadomień o statusie zamówienia
- Alertów o zmianach cen
Z obsługą błędów i możliwością wznowienia"

// AI tworzy solidny strumień zmian:
const watchInventory = async () => {
  const pipeline = [
    {
      $match: {
        $or: [
          { "fullDocument.inventory.available": { $lt: 10 } },
          { operationType: "update",
            "updateDescription.updatedFields.price": { $exists: true }
          }
        ]
      }
    }
  ];

  const options = {
    fullDocument: 'updateLookup',
    resumeAfter: savedResumeToken
  };

  const changeStream = db.collection('products')
    .watch(pipeline, options);

  changeStream.on('change', async (change) => {
    try {
      if (change.fullDocument.inventory.available < 10) {
        await notifyLowStock(change.fullDocument);
      }

      if (change.updateDescription?.updatedFields?.price) {
        await notifyPriceChange(
          change.documentKey._id,
          change.updateDescription.updatedFields.price
        );
      }

      // Zapisz token wznowienia
      await saveResumeToken(change._id);

    } catch (error) {
      console.error('Błąd strumienia zmian:', error);
      // Implementuj ponawianie z wykładniczym odroczeniem
    }
  });

  changeStream.on('error', (error) => {
    console.error('Krytyczny błąd strumienia zmian:', error);
    // Uruchom ponownie z zapisanym tokenem wznowienia
    setTimeout(() => watchInventory(), 5000);
  });
};

Wzorce magazynów klucz-wartość (Redis, DynamoDB)

Strategie cachowania

Inteligentne zarządzanie cache

# Poproś o wzorzec cachowania z AI
"Implementuj warstwę cachowania Redis z:
- Wzorcem cache-aside dla sesji użytkowników
- Write-through dla katalogu produktów
- Zarządzaniem TTL opartym na typie danych
- Strategiami podgrzewania cache
- Unieważnianiem przy aktualizacjach"

# AI generuje kompleksowe rozwiązanie cachowania:
import redis
import json
from datetime import datetime, timedelta
from functools import wraps
import hashlib

class IntelligentCache:
    def __init__(self, redis_client):
        self.redis = redis_client
        self.ttl_config = {
            'user_session': 3600,      # 1 godzina
            'product_detail': 300,     # 5 minut
            'category_list': 86400,    # 24 godziny
            'search_results': 60,      # 1 minuta
            'user_cart': 7200         # 2 godziny
        }

    def cache_aside(self, key_prefix, ttl_type='default'):
        """Dekorator dla wzorca cache-aside"""
        def decorator(func):
            @wraps(func)
            async def wrapper(*args, **kwargs):
                # Wygeneruj klucz cache
                cache_key = self._generate_key(key_prefix, args, kwargs)

                # Spróbuj pobrać z cache
                cached = await self.redis.get(cache_key)
                if cached:
                    return json.loads(cached)

                # Pobierz ze źródła
                result = await func(*args, **kwargs)

                # Przechowaj w cache z odpowiednim TTL
                ttl = self.ttl_config.get(ttl_type, 300)
                await self.redis.setex(
                    cache_key,
                    ttl,
                    json.dumps(result)
                )

                return result
            return wrapper
        return decorator

    def write_through(self, key_prefix, ttl_type='default'):
        """Dekorator dla cachowania write-through"""
        def decorator(func):
            @wraps(func)
            async def wrapper(*args, **kwargs):
                # Wykonaj operację zapisu
                result = await func(*args, **kwargs)

                # Zaktualizuj cache natychmiast
                cache_key = self._generate_key(key_prefix, args, kwargs)
                ttl = self.ttl_config.get(ttl_type, 300)

                await self.redis.setex(
                    cache_key,
                    ttl,
                    json.dumps(result)
                )

                # Unieważnij powiązane cache
                await self._invalidate_related(key_prefix, result)

                return result
            return wrapper
        return decorator

    async def warm_cache(self, warming_queries):
        """Wstępnie wypełnij cache często wykorzystywanymi danymi"""
        for query in warming_queries:
            key = query['key']
            fetcher = query['fetcher']
            ttl_type = query.get('ttl_type', 'default')

            try:
                data = await fetcher()
                ttl = self.ttl_config.get(ttl_type, 300)
                await self.redis.setex(key, ttl, json.dumps(data))
            except Exception as e:
                print(f"Podgrzewanie cache nie powiodło się dla {key}: {e}")

    def _generate_key(self, prefix, args, kwargs):
        """Generuj spójne klucze cache"""
        key_data = f"{prefix}:{args}:{sorted(kwargs.items())}"
        return hashlib.md5(key_data.encode()).hexdigest()

    async def _invalidate_related(self, prefix, data):
        """Unieważnij powiązane wpisy cache"""
        patterns = {
            'product_update': ['category:*', 'search:*'],
            'user_update': ['session:*', 'cart:*'],
            'order_create': ['inventory:*', 'user_orders:*']
        }

        if prefix in patterns:
            for pattern in patterns[prefix]:
                keys = await self.redis.keys(pattern)
                if keys:
                    await self.redis.delete(*keys)

# Przykład użycia z wzorcami sugerowanymi przez AI
cache = IntelligentCache(redis_client)

@cache.cache_aside('product', ttl_type='product_detail')
async def get_product(product_id):
    # Pobierz z bazy danych
    return await db.products.find_one({'_id': product_id})

@cache.write_through('product', ttl_type='product_detail')
async def update_product(product_id, updates):
    # Zaktualizuj bazę danych i cache
    return await db.products.update_one(
        {'_id': product_id},
        {'$set': updates}
    )

Wzorce DynamoDB

Projektowanie jednej tabeli

// Poproś o projekt DynamoDB z AI
"Zaprojektuj schemat jednej tabeli DynamoDB dla wielodostępnego SaaS:
- Użytkownicy, organizacje, projekty, zadania
- Wzorce dostępu: według użytkownika, według organizacji, według projektu
- GSI dla elastyczności zapytań
- Efektywna paginacja"

// AI dostarcza kompleksowy projekt:
const tableDesign = {
  TableName: 'SaaSPlatform',

  // Projekt klucza głównego
  PartitionKey: 'PK',
  SortKey: 'SK',

  // Wzorce encji
  entities: {
    Organization: {
      PK: 'ORG#${orgId}',
      SK: 'ORG#${orgId}',
      GSI1PK: 'ORG#${orgId}',
      GSI1SK: 'METADATA'
    },

    User: {
      PK: 'USER#${userId}',
      SK: 'USER#${userId}',
      GSI1PK: 'ORG#${orgId}',
      GSI1SK: 'USER#${userId}',
      GSI2PK: 'EMAIL#${email}',
      GSI2SK: 'USER#${userId}'
    },

    Project: {
      PK: 'ORG#${orgId}',
      SK: 'PROJECT#${projectId}',
      GSI1PK: 'PROJECT#${projectId}',
      GSI1SK: 'METADATA',
      GSI2PK: 'USER#${ownerId}',
      GSI2SK: 'PROJECT#${projectId}'
    },

    Task: {
      PK: 'PROJECT#${projectId}',
      SK: 'TASK#${taskId}',
      GSI1PK: 'USER#${assigneeId}',
      GSI1SK: 'TASK#${dueDate}#${taskId}',
      GSI2PK: 'ORG#${orgId}',
      GSI2SK: 'TASK#${status}#${taskId}'
    }
  },

  // Implementacja wzorców dostępu
  accessPatterns: {
    // Pobierz organizację ze wszystkimi użytkownikami
    getOrgWithUsers: {
      operation: 'Query',
      index: 'GSI1',
      keyCondition: 'GSI1PK = :orgId AND begins_with(GSI1SK, "USER#")',
      example: `
        const params = {
          TableName: 'SaaSPlatform',
          IndexName: 'GSI1',
          KeyConditionExpression: 'GSI1PK = :pk AND begins_with(GSI1SK, :sk)',
          ExpressionAttributeValues: {
            ':pk': 'ORG#123',
            ':sk': 'USER#'
          }
        };
      `
    },

    // Pobierz zadania użytkownika ze wszystkich projektów
    getUserTasks: {
      operation: 'Query',
      index: 'GSI1',
      keyCondition: 'GSI1PK = :userId AND begins_with(GSI1SK, "TASK#")',
      example: `
        const params = {
          TableName: 'SaaSPlatform',
          IndexName: 'GSI1',
          KeyConditionExpression: 'GSI1PK = :pk AND GSI1SK >= :start',
          ExpressionAttributeValues: {
            ':pk': 'USER#456',
            ':start': 'TASK#2024-01-01'
          },
          ScanIndexForward: true // Sortuj według terminu
        };
      `
    }
  }
};

// Helper operacji wsadowych
class DynamoDBHelper {
  async batchWrite(items) {
    const chunks = this.chunkArray(items, 25); // Limit DynamoDB

    for (const chunk of chunks) {
      const params = {
        RequestItems: {
          'SaaSPlatform': chunk.map(item => ({
            PutRequest: { Item: item }
          }))
        }
      };

      await this.dynamoDb.batchWrite(params).promise();
    }
  }

  async pagedQuery(params, pageSize = 100) {
    const results = [];
    let lastEvaluatedKey = null;

    do {
      const queryParams = {
        ...params,
        Limit: pageSize,
        ...(lastEvaluatedKey && { ExclusiveStartKey: lastEvaluatedKey })
      };

      const response = await this.dynamoDb.query(queryParams).promise();
      results.push(...response.Items);
      lastEvaluatedKey = response.LastEvaluatedKey;

    } while (lastEvaluatedKey);

    return results;
  }
}

Wzorce baz danych grafowych (Neo4j, Amazon Neptune)

Modelowanie relacji

Projektowanie grafów wspomagane przez AI

// Poproś o model grafu z AI
"Zaprojektuj model grafu Neo4j dla sieci społecznościowej z:
- Użytkownikami, postami, komentarzami, reakcjami
- Relacjami przyjaźni ze statusem prośby
- Rekomendacjami treści opartymi na połączeniach
- Wzorcami wykrywania oszustw"

// AI generuje kompleksowe schematy Cypher:

// Definicje węzłów
CREATE CONSTRAINT user_id IF NOT EXISTS
ON (u:User) ASSERT u.id IS UNIQUE;

CREATE CONSTRAINT post_id IF NOT EXISTS
ON (p:Post) ASSERT p.id IS UNIQUE;

// Węzły użytkowników z właściwościami
CREATE (u:User {
  id: 'user123',
  username: 'jankowalski',
  email: 'jan@example.com',
  created: datetime(),
  reputation: 100,
  verified: true
})

// Wzorce relacji
// Przyjaźń ze statusem
CREATE (u1:User)-[:FRIEND_REQUEST {
  sent: datetime(),
  status: 'pending',
  message: 'Cześć, połączmy się!'
}]->(u2:User)

// Po akceptacji
MATCH (u1:User)-[r:FRIEND_REQUEST]->(u2:User)
WHERE r.status = 'pending'
CREATE (u1)-[:FRIENDS {since: datetime()}]->(u2)
CREATE (u2)-[:FRIENDS {since: datetime()}]->(u1)
DELETE r

// Tworzenie treści i interakcje
CREATE (u:User)-[:POSTED {
  timestamp: datetime(),
  device: 'mobile',
  location: point({latitude: 52.2297, longitude: 21.0122})
}]->(p:Post {
  id: 'post456',
  content: 'Sprawdźcie tę bazę danych grafową!',
  tags: ['neo4j', 'graphdb', 'nosql'],
  visibility: 'public'
})

// Złożone zapytanie rekomendacji
MATCH (user:User {id: $userId})-[:FRIENDS]-(friend:User)
MATCH (friend)-[:LIKED|SHARED]->(content:Post)
WHERE NOT (user)-[:VIEWED]->(content)
AND content.created > datetime() - duration('P7D')
WITH content, COUNT(DISTINCT friend) as friendInteractions
MATCH (content)<-[:POSTED]-(author:User)
OPTIONAL MATCH (content)-[:TAGGED_WITH]->(tag:Tag)<-[:INTERESTED_IN]-(user)
RETURN content, author,
       friendInteractions,
       COUNT(tag) as relevantTags
ORDER BY friendInteractions DESC, relevantTags DESC
LIMIT 10

Algorytmy grafowe

Wykrywanie społeczności

// Wykrywanie społeczności wspomagane przez AI
"Implementuj wykrywanie społeczności dla:
- Znajdowania grup użytkowników o podobnych zainteresowaniach
- Wykrywania komór pogłosowych
- Identyfikacji liderów opinii
Używając Neo4j Graph Data Science"

// AI generuje implementację GDS:
// Utwórz projekcję grafu w pamięci
CALL gds.graph.project(
  'social-network',
  ['User', 'Post', 'Tag'],
  {
    FRIENDS: {orientation: 'UNDIRECTED'},
    LIKED: {orientation: 'NATURAL'},
    POSTED: {orientation: 'NATURAL'},
    INTERESTED_IN: {orientation: 'NATURAL'}
  }
)

// Uruchom wykrywanie społeczności Louvain
CALL gds.louvain.stream('social-network', {
  relationshipWeightProperty: 'weight',
  includeIntermediateCommunities: true,
  concurrency: 4
})
YIELD nodeId, communityId, intermediateCommunityIds
WITH gds.util.asNode(nodeId) AS user,
     communityId,
     intermediateCommunityIds
WHERE user:User
SET user.communityId = communityId

// Analiza społeczności
MATCH (u:User)
WITH u.communityId as community, COUNT(u) as size
WHERE size > 10
MATCH (member:User {communityId: community})
OPTIONAL MATCH (member)-[:INTERESTED_IN]->(tag:Tag)
WITH community, size, COLLECT(DISTINCT tag.name) as interests
RETURN community, size, interests[0..5] as topInterests
ORDER BY size DESC

Wykrywanie oszustw

// Wykrywanie wzorców oszustw wspomagane przez AI
"Utwórz zapytania wykrywania oszustw dla:
- Siatek fałszywych kont
- Skoordynowanych nieautentycznych zachowań
- Wzorców prania pieniędzy
- Podejrzanych sieci transakcji"

// Wykryj siatki kont
MATCH path = (u1:User)-[:FRIENDS]-(u2:User)
WHERE u1.created > datetime() - duration('P30D')
AND u2.created > datetime() - duration('P30D')
AND u1.id < u2.id
WITH u1, u2,
     abs(duration.inSeconds(u1.created, u2.created)) as timeDiff
WHERE timeDiff < 3600 // Utworzone w ciągu 1 godziny

// Znajdź gęste podgrafy
MATCH (u1)-[:FRIENDS]-(common:User)-[:FRIENDS]-(u2)
WITH u1, u2, COUNT(DISTINCT common) as mutualFriends
WHERE mutualFriends > 5

// Sprawdź podobne atrybuty
WITH u1, u2, mutualFriends,
     CASE
       WHEN u1.ipAddress = u2.ipAddress THEN 1
       ELSE 0
     END as sameIP,
     CASE
       WHEN substring(u1.email, 0, 5) = substring(u2.email, 0, 5) THEN 1
       ELSE 0
     END as similarEmail
WHERE sameIP + similarEmail > 0

CREATE (alert:FraudAlert {
  type: 'FAKE_ACCOUNT_RING',
  severity: 'HIGH',
  detected: datetime(),
  users: [u1.id, u2.id],
  evidence: {
    mutualFriends: mutualFriends,
    sameIP: sameIP = 1,
    similarEmail: similarEmail = 1,
    accountAge: duration.inDays(u1.created, datetime())
  }
})

MERGE (u1)-[:FLAGGED_WITH]->(alert)
MERGE (u2)-[:FLAGGED_WITH]->(alert)

Wzorce wyszukiwania wektorowego

Przechowywanie i pobieranie wektorów

Wyszukiwanie wektorowe wspomagane przez AI

# Poproś o implementację wyszukiwania wektorowego
"Implementuj system wyszukiwania wektorowego używając MongoDB Atlas z:
- Wielomodalnymi wektorami (tekst + obraz)
- Wyszukiwaniem hybrydowym (wektor + filtrowanie metadanych)
- Rekomendacjami semantycznymi produktów
- Wykrywaniem podobnych użytkowników"

# AI generuje kompleksowe rozwiązanie:
import numpy as np
from sentence_transformers import SentenceTransformer
from pymongo import MongoClient
import torch
from PIL import Image

class VectorSearchSystem:
    def __init__(self, connection_string):
        self.client = MongoClient(connection_string)
        self.db = self.client.ecommerce
        self.text_model = SentenceTransformer('all-MiniLM-L6-v2')
        self.image_model = SentenceTransformer('clip-ViT-B-32')

    async def index_product(self, product):
        """Wygeneruj i przechowaj wielomodalne wektory"""
        # Wektor tekstowy z opisu
        text_embedding = self.text_model.encode(
            f"{product['name']} {product['description']} {' '.join(product['categories'])}"
        ).tolist()

        # Wektory obrazów
        image_embeddings = []
        for image_url in product['images']:
            image = Image.open(image_url)
            img_embedding = self.image_model.encode(image).tolist()
            image_embeddings.append(img_embedding)

        # Średni wektor obrazów
        if image_embeddings:
            avg_image_embedding = np.mean(image_embeddings, axis=0).tolist()
        else:
            avg_image_embedding = None

        # Zaktualizuj produkt wektorami
        await self.db.products.update_one(
            {'_id': product['_id']},
            {
                '$set': {
                    'text_embedding': text_embedding,
                    'image_embedding': avg_image_embedding,
                    'indexed_at': datetime.utcnow()
                }
            }
        )

    async def hybrid_search(self, query, filters=None, limit=10):
        """Połącz wyszukiwanie wektorowe z filtrowaniem metadanych"""
        # Wygeneruj wektor zapytania
        query_embedding = self.text_model.encode(query).tolist()

        # Zbuduj potok agregacji
        pipeline = []

        # Etap pre-filtrowania (jeśli podano filtry)
        if filters:
            pipeline.append({'$match': filters})

        # Etap wyszukiwania wektorowego
        pipeline.extend([
            {
                '$vectorSearch': {
                    'index': 'product_embeddings',
                    'path': 'text_embedding',
                    'queryVector': query_embedding,
                    'numCandidates': limit * 10,
                    'limit': limit
                }
            },
            {
                '$addFields': {
                    'search_score': {'$meta': 'vectorSearchScore'}
                }
            }
        ])

        # Post-przetwarzanie
        pipeline.extend([
            {
                '$lookup': {
                    'from': 'reviews',
                    'localField': '_id',
                    'foreignField': 'productId',
                    'as': 'reviews'
                }
            },
            {
                '$addFields': {
                    'avgRating': {'$avg': '$reviews.rating'},
                    'reviewCount': {'$size': '$reviews'}
                }
            },
            {
                '$project': {
                    'text_embedding': 0,
                    'image_embedding': 0,
                    'reviews': 0
                }
            }
        ])

        results = await self.db.products.aggregate(pipeline).to_list(limit)
        return results

    async def find_similar_users(self, user_id, threshold=0.8):
        """Znajdź użytkowników o podobnych preferencjach używając podobieństwa wektorowego"""
        # Pobierz wektory interakcji użytkownika
        user = await self.db.users.find_one({'_id': user_id})

        if not user.get('preference_embedding'):
            # Wygeneruj wektor preferencji z interakcji użytkownika
            preference_embedding = await self._calculate_user_preferences(user_id)
            await self.db.users.update_one(
                {'_id': user_id},
                {'$set': {'preference_embedding': preference_embedding}}
            )
        else:
            preference_embedding = user['preference_embedding']

        # Znajdź podobnych użytkowników
        similar_users = await self.db.users.aggregate([
            {
                '$vectorSearch': {
                    'index': 'user_preferences',
                    'path': 'preference_embedding',
                    'queryVector': preference_embedding,
                    'numCandidates': 100,
                    'limit': 20
                }
            },
            {
                '$match': {
                    '_id': {'$ne': user_id},
                    'search_score': {'$gte': threshold}
                }
            },
            {
                '$project': {
                    'username': 1,
                    'similarity': {'$meta': 'vectorSearchScore'},
                    'common_interests': 1
                }
            }
        ]).to_list(20)

        return similar_users

# Utwórz indeksy wyszukiwania wektorowego
async def setup_indexes(db):
    # Indeks wektora tekstowego produktu
    await db.command({
        'createSearchIndex': {
            'name': 'product_embeddings',
            'definition': {
                'mappings': {
                    'dynamic': True,
                    'fields': {
                        'text_embedding': {
                            'type': 'knnVector',
                            'dimensions': 384,
                            'similarity': 'cosine'
                        },
                        'categories': {
                            'type': 'string',
                            'analyzer': 'lucene.standard'
                        },
                        'price': {
                            'type': 'number'
                        }
                    }
                }
            }
        }
    })

Optymalizacja wydajności

Optymalizacje specyficzne dla NoSQL

Strategia indeksów

"Optymalizuj indeksy MongoDB dla:
- Zapytań o wysokiej kardynalności
- Wyboru indeksów złożonych
- Przecięcia indeksów
- Zapytań pokrywanych"

// AI sugeruje optymalne indeksy:
// Najpierw przeanalizuj wzorce zapytań
db.setProfilingLevel(2);

// Przejrzyj wolne zapytania
db.system.profile.aggregate([
  { $match: { millis: { $gt: 100 } } },
  { $group: {
    _id: "$command.filter",
    count: { $sum: 1 },
    avgMillis: { $avg: "$millis" }
  }},
  { $sort: { avgMillis: -1 } }
]);

// Utwórz strategiczne indeksy
db.orders.createIndex(
  { userId: 1, status: 1, createdAt: -1 },
  { name: "user_orders_idx" }
);

Strategia shardingu

"Zaprojektuj strategię shardingu dla:
- 100M+ dokumentów
- Dystrybucji geograficznej
- Danych szeregów czasowych
- Równomiernej dystrybucji"

// AI rekomenduje:
sh.enableSharding("analytics");

// Sharding hashowany dla równomiernej dystrybucji
sh.shardCollection(
  "analytics.events",
  { userId: "hashed" }
);

// Sharding zakresowy dla szeregów czasowych
sh.shardCollection(
  "analytics.metrics",
  { timestamp: 1, source: 1 }
);

Pooling połączeń

"Optymalizuj pooling połączeń dla:
- Wysokiej współbieżności
- Obsługi failover
- Preferencji odczytu
- Limitów połączeń"

# AI konfiguruje optymalny pooling:
client = MongoClient(
  connection_string,
  maxPoolSize=100,
  minPoolSize=10,
  maxIdleTimeMS=30000,
  waitQueueTimeoutMS=5000,
  retryWrites=True,
  retryReads=True,
  readPreference='secondaryPreferred',
  readConcernLevel='majority',
  w='majority',
  wtimeout=5000
)

Zarządzanie pamięcią

"Skonfiguruj cache WiredTiger:
- Analiza zestawu roboczego
- Optymalizacja rozmiaru cache
- Ustawienia kompresji
- Interwały punktów kontrolnych"

// AI dostarcza konfigurację:
// mongod.conf
storage:
  wiredTiger:
    engineConfig:
      cacheSizeGB: 8
      journalCompressor: snappy
      directoryForIndexes: true
    collectionConfig:
      blockCompressor: zstd
    indexConfig:
      prefixCompression: true

Wzorce migracji

Migracja z RDBMS do NoSQL

// Poproś o strategię migracji z AI
"Migruj relacyjną bazę danych do MongoDB:
- Zdenormalizuj klucze obce
- Obsłuż transakcje
- Zachowaj integralność danych
- Optymalizuj pod wzorce NoSQL"

// AI dostarcza框架 migracji:
class RDBMSToNoSQLMigrator {
  async migrateSchema(sqlSchema) {
    const collections = {};

    // Przeanalizuj klucze obce dla osadzania vs referencji
    for (const table of sqlSchema.tables) {
      const relationships = this.analyzeRelationships(table);

      if (relationships.oneToFew) {
        // Osadź powiązane dokumenty
        collections[table.name] = {
          ...table.columns,
          [relationships.related]: {
            type: 'embedded',
            source: relationships.relatedTable
          }
        };
      } else if (relationships.oneToMany) {
        // Użyj referencji z zdenormalizowanymi danymi
        collections[table.name] = {
          ...table.columns,
          [relationships.related]: {
            type: 'reference',
            denormalized: ['name', 'status']
          }
        };
      }
    }

    return collections;
  }

  async migrateData(source, target, batchSize = 1000) {
    // Przetwarzaj dane z transformacjami
    const cursor = source.query('SELECT * FROM users');
    const batch = [];

    for await (const row of cursor) {
      const doc = await this.transformRow(row);
      batch.push(doc);

      if (batch.length >= batchSize) {
        await target.insertMany(batch);
        batch.length = 0;
      }
    }

    // Wstaw pozostałe
    if (batch.length > 0) {
      await target.insertMany(batch);
    }
  }

  async verifyMigration(source, target) {
    // Porównaj liczniki
    const sourceCount = await source.count();
    const targetCount = await target.countDocuments();

    // Weryfikacja próbek danych
    const samples = await source.query(
      'SELECT * FROM users ORDER BY RANDOM() LIMIT 100'
    );

    for (const sample of samples) {
      const doc = await target.findOne({ _id: sample.id });
      this.validateTransformation(sample, doc);
    }
  }
}

Podsumowanie najlepszych praktyk

Rozwój NoSQL z AI

Kluczowe wnioski:

1. Projektowanie schematów: Pozwól AI pomóc ci zrównoważyć osadzanie i referencje w oparciu o wzorce dostępu
2. Optymalizacja zapytań: Użyj AI do generowania złożonych potoków agregacji i optymalizacji istniejących zapytań
3. Strategie skalowania: Wykorzystaj AI do wyboru kluczy shardingu i rekomendacji indeksów
4. Planowanie migracji: AI może analizować schematy relacyjne i sugerować optymalne struktury NoSQL
5. Dostrajanie wydajności: Użyj AI do identyfikacji wąskich gardeł i sugerowania popraw konfiguracji

Pamiętaj:

• Elastyczność NoSQL nie oznacza braku planowania - używaj AI do przemyślanego projektowania
• Monitoruj wzorce zapytań i pozwól AI sugerować optymalizacje
• Testuj zapytania generowane przez AI z wolumenami danych podobnymi do produkcyjnych
• Miej na uwadze bezpieczeństwo - waliduj wszystkie zapytania sugerowane przez AI
• Dokumentuj decyzje dotyczące schematów dla zrozumienia zespołu

Ciągłe uczenie się

Bazy danych NoSQL rozwijają się szybko z nowymi funkcjami i możliwościami. Używaj asystentów AI, aby być na bieżąco z najlepszymi praktykami, nowymi operatorami i optymalizacjami wydajności. Regularne przeglądy twoich modeli danych z pomocą AI mogą ujawnić możliwości optymalizacji w miarę rozwoju aplikacji.