NoSQL Databases

db.users.insertOne({
  name: "Alice Johnson",
  email: "alice@example.com",
  age: 28,
  interests: ["coding", "hiking", "photography"],
  address: {
    city: "San Francisco",
    state: "CA",
    zip: "94102"
  },
  created_at: new Date()
});

db.users.find({
  age: { $gte: 25 },
  "address.city": "San Francisco"
});

db.users.updateOne(
  { email: "alice@example.com" },
  { 
    $set: { age: 29 },
    $push: { interests: "cooking" }
  }
);

db.orders.aggregate([
  { $match: { status: "completed" } },
  { $group: { 
      _id: "$customer_id", 
      total_spent: { $sum: "$amount" },
      order_count: { $sum: 1 }
  }},
  { $sort: { total_spent: -1 } },
  { $limit: 10 }
]);

SET user:1000:name "Alice Johnson"
SET user:1000:email "alice@example.com"
SET session:xyz123 "user_data" EX 3600

GET user:1000:name
MGET user:1000:name user:1000:email

LPUSH queue:tasks "process_payment"
LPUSH queue:tasks "send_email"
RPOP queue:tasks

ZADD leaderboard 1500 "player1"
ZADD leaderboard 2300 "player2"
ZADD leaderboard 1800 "player3"
-- Top 3, highest first. ZRANGE ... REV replaces ZREVRANGE,
-- which has been deprecated since Redis 6.2.
ZRANGE leaderboard 0 2 REV WITHSCORES

HSET user:1000 name "Alice" email "alice@example.com" age 28
HGETALL user:1000
HINCRBY user:1000 age 1

-- NetworkTopologyStrategy is the production choice: it places replicas
-- across datacenters/racks. SimpleStrategy exists for single-DC toys and
-- is discouraged in Cassandra 4+ (it cannot express topology at all).
CREATE KEYSPACE ecommerce
WITH replication = {
  'class': 'NetworkTopologyStrategy',
  'dc1': 3
};

CREATE TABLE user_activity (
  user_id UUID,
  activity_date DATE,
  activity_time TIMESTAMP,
  action TEXT,
  details MAP<TEXT, TEXT>,
  PRIMARY KEY ((user_id), activity_date, activity_time)
) WITH CLUSTERING ORDER BY (activity_date DESC, activity_time DESC);

INSERT INTO user_activity (user_id, activity_date, activity_time, action, details)
VALUES (
  uuid(),
  '2024-01-15',
  toTimestamp(now()),
  'page_view',
  {'page': '/products', 'duration': '45s'}
);

SELECT * FROM user_activity
WHERE user_id = '550e8400-e29b-41d4-a716-446655440000'
AND activity_date >= '2024-01-01'
LIMIT 10;

CREATE (alice:Person {name: 'Alice', age: 28})
CREATE (bob:Person {name: 'Bob', age: 32})
CREATE (coding:Skill {name: 'Coding', level: 'Advanced'})

MATCH (a:Person {name: 'Alice'}), (b:Person {name: 'Bob'})
CREATE (a)-[:KNOWS {since: 2020}]->(b)

MATCH (a:Person {name: 'Alice'}), (s:Skill {name: 'Coding'})
CREATE (a)-[:HAS_SKILL {years: 5}]->(s)

MATCH (person:Person {name: 'Alice'})-[:KNOWS]->(friend)-[:KNOWS]->(fof)
WHERE NOT (person)-[:KNOWS]->(fof) AND person <> fof
RETURN fof.name, COUNT(*) AS mutual_friends
ORDER BY mutual_friends DESC

MATCH path = shortestPath(
  (alice:Person {name: 'Alice'})-[:KNOWS*]-(target:Person {name: 'Eve'})
)
RETURN [node in nodes(path) | node.name] AS connection_path,
       length(path) AS degrees_of_separation

MATCH (person:Person {name: 'Alice'})-[:LIKES]->(item:Product)
      <-[:LIKES]-(other:Person)-[:LIKES]->(recommendation:Product)
WHERE NOT (person)-[:LIKES]->(recommendation)
RETURN recommendation.name, COUNT(*) AS score
ORDER BY score DESC
LIMIT 5

temperature,location=office,sensor=sensor1 value=22.5 1642464000000000000
temperature,location=office,sensor=sensor1 value=23.1 1642464060000000000
temperature,location=warehouse,sensor=sensor2 value=18.3 1642464000000000000

from(bucket: "sensors")
  |> range(start: -1h)
  |> filter(fn: (r) => r._measurement == "temperature")
  |> filter(fn: (r) => r.location == "office")
  |> mean()

from(bucket: "sensors")
  |> range(start: -24h)
  |> filter(fn: (r) => r._measurement == "cpu_usage")
  |> aggregateWindow(every: 5m, fn: mean)
  |> yield(name: "mean_5m")

from(bucket: "sensors")
  |> range(start: -1h)
  |> filter(fn: (r) => r._measurement == "temperature")
  |> filter(fn: (r) => r._value > 30.0 or r._value < 10.0)
  |> group(columns: ["location"])

POST /products/_doc/1
{
  "name": "Wireless Headphones",
  "description": "Premium noise-canceling headphones with Bluetooth 5.0",
  "price": 199.99,
  "category": "Electronics",
  "tags": ["audio", "wireless", "bluetooth"]
}

GET /products/_search
{
  "query": {
    "multi_match": {
      "query": "bluetooth headphones",
      "fields": ["name^2", "description"]
    }
  }
}

GET /products/_search
{
  "query": {
    "match": {
      "name": {
        "query": "headphnes",
        "fuzziness": "AUTO"
      }
    }
  }
}

GET /products/_search
{
  "query": {
    "bool": {
      "must": [{"match": {"category": "Electronics"}}],
      "filter": [{"range": {"price": {"gte": 100, "lte": 300}}}]
    }
  },
  "aggs": {
    "price_ranges": {
      "range": {
        "field": "price",
        "ranges": [
          {"to": 100}, {"from": 100, "to": 200}, {"from": 200}
        ]
      }
    }
  }
}

GET /products/_search
{
  "query": {
    "match_phrase_prefix": {
      "name": {
        "query": "wirele"
      }
    }
  },
  "size": 5
}

from pinecone import Pinecone

pc = Pinecone(api_key="YOUR_API_KEY")
index = pc.Index("documents")

index.upsert([
  {
    "id": "doc1",
    "values": [0.1, 0.2, 0.3, ..., 0.8],  # 1536-dim embedding
    "metadata": {
      "text": "Machine learning is a subset of AI",
      "category": "AI"
    }
  },
  {
    "id": "doc2",
    "values": [0.2, 0.1, 0.4, ..., 0.7],
    "metadata": {
      "text": "Deep learning uses neural networks",
      "category": "AI"
    }
  }
])

query_vector = [0.15, 0.18, 0.35, ..., 0.75]  # Query embedding

results = index.query(
  vector=query_vector,
  top_k=3,
  include_metadata=True
)

results = index.query(
  vector=query_vector,
  top_k=5,
  filter={"category": {"$eq": "AI"}},
  include_metadata=True
)

from openai import OpenAI

client = OpenAI()

# 1. Convert user question to embedding
question = "What is machine learning?"
embedding = client.embeddings.create(
  model="text-embedding-3-small",
  input=question
).data[0].embedding

# 2. Find relevant documents
results = index.query(vector=embedding, top_k=3, include_metadata=True)

# 3. Create context from results
context = "\n".join([m.metadata["text"] for m in results.matches])

# 4. Send to LLM with context
response = client.chat.completions.create(
  model="gpt-4o-mini",
  messages=[
    {"role": "system", "content": f"Context: {context}"},
    {"role": "user", "content": question}
  ]
)

// Insert document. save() is the old name; insert() is current.
db._create("users");
db.users.insert({
  _key: "alice",          // explicit key, so we can reference users/alice
  name: "Alice",
  email: "alice@example.com",
  age: 28
});

// Create edge collection for relationships
db._createEdgeCollection("knows");

// _from and _to reference documents by their full id, which is
// "<collection>/<_key>". This is why we set _key explicitly above.
db.knows.insert({
  _from: "users/alice",
  _to: "users/bob",
  since: 2020
});

// Query combining documents and graph traversal
FOR user IN users
  FILTER user.age >= 25
  FOR friend IN 1..2 OUTBOUND user knows
    RETURN {
      user: user.name,
      friend: friend.name,
      friendAge: friend.age
    }

// Fast key-value lookup by _key
db.users.document("alice")

// Or by the full id
db.users.document("users/alice")