Real-Time Processing

Real-time processing in Geode enables applications to query and analyze graph data with millisecond latency, react to data changes instantly, and maintain up-to-date materialized views. Geode’s architecture is optimized for concurrent read/write workloads with predictable performance. <h3 id="what-is-real-time-graph-processing" class="position-relative d-flex align-items-center group"> What Is Real-Time Graph Processing? <button type="button" class="h-share btn btn-link p-0 text-decoration-none link-secondary opacity-50 hover-opacity-100 transition-all ms-1" data-share-target="what-is-real-time-graph-processing" aria-haspopup="dialog" aria-label="Share link: What Is Real-Time Graph Processing?"> Share link </button> </h3><div id="headingShareModal" class="heading-share-modal" role="dialog" aria-modal="true" aria-labelledby="headingShareTitle" hidden> <div class="hsm-dialog" role="document"> <div class="hsm-header"> <h2 id="headingShareTitle" class="h6 mb-0 fw-bold">Share this section</h2> <button type="button" class="hsm-close" aria-label="Close"> </button> </div> <div class="hsm-body"> <label for="headingShareInput" class="form-label small text-muted mb-1 text-uppercase fw-bold" style="font-size: 0.7rem; letter-spacing: 0.5px;">Permalink</label> <div class="input-group mb-4 hsm-url-group"> <input id="headingShareInput" type="text" class="form-control font-monospace" readonly aria-readonly="true" style="font-size: 0.85rem;" /> <button class="btn btn-primary hsm-copy" type="button" aria-label="Copy" title="Copy"> </button> </div> <div class="small fw-bold mb-2 text-muted text-uppercase" style="font-size: 0.7rem; letter-spacing: 0.5px;">Share via</div> <div class="hsm-share-grid"> <a id="share-twitter" class="btn btn-outline-secondary w-100" target="_blank" rel="noopener noreferrer"> Twitter </a> <a id="share-linkedin" class="btn btn-outline-secondary w-100" target="_blank" rel="noopener noreferrer"> LinkedIn </a> <a id="share-facebook" class="btn btn-outline-secondary w-100" target="_blank" rel="noopener noreferrer"> Facebook </a> </div> </div> </div> </div> <style> .heading-share-modal { position: fixed; inset: 0; display: flex; justify-content: center; align-items: center; background: rgba(0, 0, 0, 0.6); z-index: 1050; padding: 1rem; backdrop-filter: blur(4px); -webkit-backdrop-filter: blur(4px); } .heading-share-modal[hidden] { display: none !important; } .hsm-dialog { max-width: 420px; width: 100%; background: var(--bs-body-bg, #fff); color: var(--bs-body-color, #212529); border: 1px solid var(--bs-border-color, rgba(0,0,0,0.1)); border-radius: 1rem; box-shadow: 0 25px 50px -12px rgba(0, 0, 0, 0.25); overflow: hidden; animation: hsm-fade-in 0.2s ease-out; } @keyframes hsm-fade-in { from { opacity: 0; transform: scale(0.95); } to { opacity: 1; transform: scale(1); } } [data-bs-theme="dark"] .hsm-dialog { background: #1e293b; border-color: rgba(255,255,255,0.1); color: #f8f9fa; } .hsm-header { display: flex; justify-content: space-between; align-items: center; padding: 1rem 1.5rem; border-bottom: 1px solid var(--bs-border-color, rgba(0,0,0,0.1)); background: rgba(0,0,0,0.02); } [data-bs-theme="dark"] .hsm-header { background: rgba(255,255,255,0.02); border-color: rgba(255,255,255,0.1); } .hsm-close { background: transparent; border: none; color: inherit; opacity: 0.5; padding: 0.25rem 0.5rem; border-radius: 0.25rem; font-size: 1.2rem; line-height: 1; transition: opacity 0.2s; } .hsm-close:hover { opacity: 1; } .hsm-body { padding: 1.5rem; } .hsm-url-group { display: flex !important; align-items: stretch; } .hsm-url-group .form-control { flex: 1; min-width: 0; margin: 0; background: var(--bs-secondary-bg, #f8f9fa); border-color: var(--bs-border-color, #dee2e6); border-top-right-radius: 0; border-bottom-right-radius: 0; height: 42px; } .hsm-url-group .btn { flex: 0 0 auto; margin: 0; margin-left: -1px; border-top-left-radius: 0; border-bottom-left-radius: 0; height: 42px; display: flex; align-items: center; justify-content: center; padding: 0 1.25rem; z-index: 2; } [data-bs-theme="dark"] .hsm-url-group .form-control { background: #0f172a; border-color: #334155; color: #e2e8f0; } .hsm-share-grid { display: flex; flex-direction: column; gap: 0.5rem; } .hsm-share-grid .btn { display: flex; align-items: center; justify-content: center; font-size: 0.9rem; padding: 0.6rem; border-color: var(--bs-border-color); width: 100%; } [data-bs-theme="dark"] .hsm-share-grid .btn { color: #e2e8f0; border-color: #475569; } [data-bs-theme="dark"] .hsm-share-grid .btn:hover { background: #334155; border-color: #cbd5e1; } </style> <script> (function(){ const modal = document.getElementById('headingShareModal'); if(!modal) return; const input = modal.querySelector('#headingShareInput'); const copyBtn = modal.querySelector('.hsm-copy'); const twitter = modal.querySelector('#share-twitter'); const linkedin = modal.querySelector('#share-linkedin'); const facebook = modal.querySelector('#share-facebook'); const closeBtn = modal.querySelector('.hsm-close'); let lastFocus=null; let trapBound=false; function buildUrl(id){ return window.location.origin + window.location.pathname + '#' + id; } function isOpen(){ return !modal.hasAttribute('hidden'); } function hydrate(id){ const url=buildUrl(id); input.value=url; const enc=encodeURIComponent(url); const text=encodeURIComponent(document.title); if(twitter) twitter.href=`https://twitter.com/intent/tweet?url=${enc}&text=${text}`; if(linkedin) linkedin.href=`https://www.linkedin.com/sharing/share-offsite/?url=${enc}`; if(facebook) facebook.href=`https://www.facebook.com/sharer/sharer.php?u=${enc}`; } function openModal(id){ lastFocus=document.activeElement; hydrate(id); if(!isOpen()){ modal.removeAttribute('hidden'); } requestAnimationFrame(()=>{ input.focus(); }); trapFocus(); } function closeModal(){ if(!isOpen()) return; modal.setAttribute('hidden',''); if(lastFocus && typeof lastFocus.focus==='function') lastFocus.focus(); } function copyCurrent(){ try{ navigator.clipboard.writeText(input.value).then(()=>feedback(true),()=>fallback()); } catch(e){ fallback(); } } function fallback(){ input.select(); try{ document.execCommand('copy'); feedback(true);}catch(e){ feedback(false);} } function feedback(ok){ if(!copyBtn) return; const icon=copyBtn.querySelector('i'); if(!icon) return; const prev=copyBtn.getAttribute('data-prev')||icon.className; if(!copyBtn.getAttribute('data-prev')) copyBtn.setAttribute('data-prev',prev); icon.className= ok ? 'fa-duotone fa-clipboard-check':'fa-duotone fa-circle-exclamation'; setTimeout(()=>{ icon.className=prev; },1800); } function handleShareClick(e){ e.preventDefault(); const btn=e.currentTarget; const id=btn.getAttribute('data-share-target'); if(id) openModal(id); } function bindShareButtons(){ document.querySelectorAll('.h-share').forEach(btn=>{ if(!btn.dataset.hShareBound){ btn.addEventListener('click', handleShareClick); btn.dataset.hShareBound='1'; } }); } bindShareButtons(); if(document.readyState==='loading'){ document.addEventListener('DOMContentLoaded', bindShareButtons); } else { requestAnimationFrame(bindShareButtons); } document.addEventListener('click', function(e){ const shareBtn=e.target.closest && e.target.closest('.h-share'); if(shareBtn && !shareBtn.dataset.hShareBound){ handleShareClick.call(shareBtn, e); } }, true); document.addEventListener('click', e=>{ if(e.target===modal) closeModal(); if(e.target.closest && e.target.closest('.hsm-close')){ e.preventDefault(); closeModal(); } if(copyBtn && (e.target===copyBtn || (e.target.closest && e.target.closest('.hsm-copy')))) { e.preventDefault(); copyCurrent(); } }); document.addEventListener('keydown', e=>{ if(e.key==='Escape' && isOpen()) closeModal(); }); function trapFocus(){ if(trapBound) return; trapBound=true; modal.addEventListener('keydown', f=>{ if(f.key==='Tab' && isOpen()){ const focusable=[...modal.querySelectorAll('a[href],button,input,textarea,select,[tabindex]:not([tabindex="-1"])')].filter(el=>!el.hasAttribute('disabled')); if(!focusable.length) return; const first=focusable[0]; const last=focusable[focusable.length-1]; if(f.shiftKey && document.activeElement===first){ f.preventDefault(); last.focus(); } else if(!f.shiftKey && document.activeElement===last){ f.preventDefault(); first.focus(); } } }); } if(closeBtn) closeBtn.addEventListener('click', e=>{ e.preventDefault(); closeModal(); }); })(); </script>Real-time graph processing involves executing queries, detecting patterns, and responding to graph changes with minimal delay. Geode achieves this through: <ul> <li>Sub-millisecond query execution via optimized indexes</li> <li>Non-blocking MVCC for concurrent operations</li> <li>Change data capture (CDC) for event streaming</li> <li>Efficient incremental computation</li> <li>Low-latency QUIC protocol</li> </ul> <h3 id="low-latency-query-execution" class="position-relative d-flex align-items-center group"> Low-Latency Query Execution <button type="button" class="h-share btn btn-link p-0 text-decoration-none link-secondary opacity-50 hover-opacity-100 transition-all ms-1" data-share-target="low-latency-query-execution" aria-haspopup="dialog" aria-label="Share link: Low-Latency Query Execution"> Share link </button> </h3> <h4 id="index-optimized-lookups" class="position-relative d-flex align-items-center group"> Index-Optimized Lookups <button type="button" class="h-share btn btn-link p-0 text-decoration-none link-secondary opacity-50 hover-opacity-100 transition-all ms-1" data-share-target="index-optimized-lookups" aria-haspopup="dialog" aria-label="Share link: Index-Optimized Lookups"> Share link </button> </h4>Geode’s indexes enable constant-time node and relationship lookups: <div class="highlight"><pre tabindex="0" class="chroma"><code class="language-gql" data-lang="gql">// Direct node lookup by indexed property (< 1ms typical) MATCH (u:User {user_id: $user_id}) RETURN u; // Indexed relationship traversal MATCH (u:User {user_id: $user_id})-[:FOLLOWS]->(friend:User) RETURN friend.user_id, friend.name; // Range query on indexed property MATCH (p:Product) WHERE p.price BETWEEN 100 AND 500 AND p.in_stock = true RETURN p.product_id, p.name, p.price ORDER BY p.price ASC LIMIT 20; </code></pre></div> <h4 id="query-performance-patterns" class="position-relative d-flex align-items-center group"> Query Performance Patterns <button type="button" class="h-share btn btn-link p-0 text-decoration-none link-secondary opacity-50 hover-opacity-100 transition-all ms-1" data-share-target="query-performance-patterns" aria-haspopup="dialog" aria-label="Share link: Query Performance Patterns"> Share link </button> </h4>Optimize queries for real-time execution: <div class="highlight"><pre tabindex="0" class="chroma"><code class="language-gql" data-lang="gql">// BAD: Unbounded traversal MATCH (start:Person {id: $id})-[:KNOWS*]-(connected) RETURN connected; // Can traverse millions of nodes // GOOD: Bounded depth with early termination MATCH path = (start:Person {id: $id})-[:KNOWS*1..3]-(connected) WHERE connected.active = true RETURN connected LIMIT 100; // Limit results for predictable latency // GOOD: Use WHERE clauses to filter early MATCH (u:User)-[:PURCHASED]->(p:Product) WHERE u.user_id = $user_id AND p.created_at > datetime().minusDays(30) RETURN p; </code></pre></div> <h4 id="prepared-statements" class="position-relative d-flex align-items-center group"> Prepared Statements <button type="button" class="h-share btn btn-link p-0 text-decoration-none link-secondary opacity-50 hover-opacity-100 transition-all ms-1" data-share-target="prepared-statements" aria-haspopup="dialog" aria-label="Share link: Prepared Statements"> Share link </button> </h4>Reduce parsing overhead for frequently executed queries: <div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"># Python client example from geode_client import Client client = Client(host="localhost", port=3141) async with client.connection() as conn: # Prepare query once stmt = await conn.prepare(""" MATCH (u:User {user_id: $user_id})-[:PURCHASED]->(p:Product) WHERE p.created_at > $since RETURN p.product_id, p.name, p.price """) # Execute multiple times with different parameters (faster) for user_id in user_ids: results, _ = await stmt.execute({ 'user_id': user_id, 'since': datetime.now() - timedelta(days=7) }) process_results(results) </code></pre></div> <h3 id="change-data-capture-cdc" class="position-relative d-flex align-items-center group"> Change Data Capture (CDC) <button type="button" class="h-share btn btn-link p-0 text-decoration-none link-secondary opacity-50 hover-opacity-100 transition-all ms-1" data-share-target="change-data-capture-cdc" aria-haspopup="dialog" aria-label="Share link: Change Data Capture (CDC)"> Share link </button> </h3> <h4 id="monitoring-graph-changes" class="position-relative d-flex align-items-center group"> Monitoring Graph Changes <button type="button" class="h-share btn btn-link p-0 text-decoration-none link-secondary opacity-50 hover-opacity-100 transition-all ms-1" data-share-target="monitoring-graph-changes" aria-haspopup="dialog" aria-label="Share link: Monitoring Graph Changes"> Share link </button> </h4>Subscribe to data change events in real-time: <div class="highlight"><pre tabindex="0" class="chroma"><code class="language-gql" data-lang="gql">// Enable CDC on specific labels CREATE CHANGE STREAM user_changes FOR (u:User) EMIT CREATED, UPDATED, DELETED; CREATE CHANGE STREAM purchase_stream FOR ()-[p:PURCHASED]->() EMIT CREATED; // Query change stream POLL CHANGE STREAM user_changes SINCE $last_sequence_number LIMIT 100; </code></pre></div> <h4 id="event-stream-processing" class="position-relative d-flex align-items-center group"> Event Stream Processing <button type="button" class="h-share btn btn-link p-0 text-decoration-none link-secondary opacity-50 hover-opacity-100 transition-all ms-1" data-share-target="event-stream-processing" aria-haspopup="dialog" aria-label="Share link: Event Stream Processing"> Share link </button> </h4>Process changes as they occur: <div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"># Python CDC consumer from geode_client import Client import asyncio async def process_user_changes(): client = await Client.connect("geodedb://localhost:3141") last_seq = 0 while True: # Poll for changes changes = await client.poll_change_stream( 'user_changes', since=last_seq, limit=100 ) for change in changes: if change['event_type'] == 'CREATED': await handle_new_user(change['after']) elif change['event_type'] == 'UPDATED': await handle_user_update(change['before'], change['after']) elif change['event_type'] == 'DELETED': await handle_user_deletion(change['before']) last_seq = change['sequence_number'] if not changes: await asyncio.sleep(0.1) # Poll interval async def handle_new_user(user_data): # Send welcome email, update cache, etc. print(f"New user: {user_data['user_id']}") </code></pre></div> <h4 id="materialized-view-maintenance" class="position-relative d-flex align-items-center group"> Materialized View Maintenance <button type="button" class="h-share btn btn-link p-0 text-decoration-none link-secondary opacity-50 hover-opacity-100 transition-all ms-1" data-share-target="materialized-view-maintenance" aria-haspopup="dialog" aria-label="Share link: Materialized View Maintenance"> Share link </button> </h4>Keep derived data up-to-date using CDC: <div class="highlight"><pre tabindex="0" class="chroma"><code class="language-gql" data-lang="gql">// Maintain user activity statistics in real-time CREATE MATERIALIZED VIEW user_stats AS SELECT u.user_id, COUNT(p) AS purchase_count, SUM(p.amount) AS total_spent, MAX(p.timestamp) AS last_purchase FROM (u:User)-[p:PURCHASED]->() GROUP BY u.user_id; // Geode automatically updates view when purchases are inserted/deleted INSERT (user:User {user_id: 'user_123'}) INSERT (product:Product {product_id: 'prod_456', price: 99.99}) INSERT (user)-[:PURCHASED { amount: 99.99, timestamp: datetime() }]->(product); // user_stats automatically reflects the new purchase </code></pre></div> <h3 id="streaming-analytics" class="position-relative d-flex align-items-center group"> Streaming Analytics <button type="button" class="h-share btn btn-link p-0 text-decoration-none link-secondary opacity-50 hover-opacity-100 transition-all ms-1" data-share-target="streaming-analytics" aria-haspopup="dialog" aria-label="Share link: Streaming Analytics"> Share link </button> </h3> <h4 id="sliding-window-aggregations" class="position-relative d-flex align-items-center group"> Sliding Window Aggregations <button type="button" class="h-share btn btn-link p-0 text-decoration-none link-secondary opacity-50 hover-opacity-100 transition-all ms-1" data-share-target="sliding-window-aggregations" aria-haspopup="dialog" aria-label="Share link: Sliding Window Aggregations"> Share link </button> </h4>Compute metrics over time windows: <div class="highlight"><pre tabindex="0" class="chroma"><code class="language-gql" data-lang="gql">// Count events in last 5 minutes MATCH (e:Event) WHERE e.timestamp > datetime().minusMinutes(5) WITH COUNT(e) AS event_count_5min, COUNT(DISTINCT e.user_id) AS unique_users_5min RETURN event_count_5min, unique_users_5min; // Hourly breakdown for real-time dashboard MATCH (e:Event) WHERE e.timestamp > datetime().minusHours(24) WITH date.truncate('hour', e.timestamp) AS hour, COUNT(e) AS event_count ORDER BY hour DESC RETURN hour, event_count; </code></pre></div> <h4 id="session-detection" class="position-relative d-flex align-items-center group"> Session Detection <button type="button" class="h-share btn btn-link p-0 text-decoration-none link-secondary opacity-50 hover-opacity-100 transition-all ms-1" data-share-target="session-detection" aria-haspopup="dialog" aria-label="Share link: Session Detection"> Share link </button> </h4>Identify user sessions in real-time: <div class="highlight"><pre tabindex="0" class="chroma"><code class="language-gql" data-lang="gql">// Detect session boundaries (30-minute inactivity threshold) MATCH (u:User {user_id: $user_id})-[:PERFORMED]->(e:Event) WHERE e.timestamp > datetime().minusHours(24) WITH u, e ORDER BY e.timestamp ASC // Group events into sessions WITH u, COLLECT(e) AS events UNWIND RANGE(0, SIZE(events) - 1) AS i WITH u, events[i] AS current_event, CASE WHEN i = 0 THEN true WHEN duration.between(events[i-1].timestamp, events[i].timestamp).minutes > 30 THEN true ELSE false END AS is_session_start WITH u, current_event, SUM(CASE WHEN is_session_start THEN 1 ELSE 0 END) OVER ( ORDER BY current_event.timestamp ) AS session_id RETURN session_id, MIN(current_event.timestamp) AS session_start, MAX(current_event.timestamp) AS session_end, COUNT(current_event) AS event_count; </code></pre></div> <h3 id="concurrent-processing" class="position-relative d-flex align-items-center group"> Concurrent Processing <button type="button" class="h-share btn btn-link p-0 text-decoration-none link-secondary opacity-50 hover-opacity-100 transition-all ms-1" data-share-target="concurrent-processing" aria-haspopup="dialog" aria-label="Share link: Concurrent Processing"> Share link </button> </h3> <h4 id="non-blocking-reads" class="position-relative d-flex align-items-center group"> Non-Blocking Reads <button type="button" class="h-share btn btn-link p-0 text-decoration-none link-secondary opacity-50 hover-opacity-100 transition-all ms-1" data-share-target="non-blocking-reads" aria-haspopup="dialog" aria-label="Share link: Non-Blocking Reads"> Share link </button> </h4>Geode’s MVCC ensures reads never block writes: <div class="highlight"><pre tabindex="0" class="chroma"><code class="language-gql" data-lang="gql">// Long-running analytical query doesn't block writes MATCH (u:User)-[:PURCHASED]->(p:Product) WITH p.category AS category, COUNT(u) AS buyer_count ORDER BY buyer_count DESC RETURN category, buyer_count; // Meanwhile, inserts proceed without waiting INSERT (new_user:User {user_id: 'user_new'}) INSERT (product:Product {product_id: 'prod_new'}) INSERT (new_user)-[:PURCHASED {timestamp: datetime()}]->(product); // Both queries execute concurrently </code></pre></div> <h4 id="connection-pooling" class="position-relative d-flex align-items-center group"> Connection Pooling <button type="button" class="h-share btn btn-link p-0 text-decoration-none link-secondary opacity-50 hover-opacity-100 transition-all ms-1" data-share-target="connection-pooling" aria-haspopup="dialog" aria-label="Share link: Connection Pooling"> Share link </button> </h4>Maximize throughput with connection pooling: <div class="highlight"><pre tabindex="0" class="chroma"><code class="language-go" data-lang="go">// Go client with connection pooling package main import ( "context" "log" "sync" "geodedb.com/geode" ) func main() { // Create connection pool db, err := geode.Open("geodedb://localhost:3141") if err != nil { log.Fatal(err) } defer db.Close() // Configure pool db.SetMaxOpenConns(100) // Max connections db.SetMaxIdleConns(10) // Keep 10 idle connections ready // Execute queries concurrently var wg sync.WaitGroup for i := 0; i < 1000; i++ { wg.Add(1) go func(userID string) { defer wg.Done() row := db.QueryRowContext(context.Background(), "MATCH (u:User {user_id: $user_id}) RETURN u", geode.Param("user_id", userID)) // Process result... }(fmt.Sprintf("user_%d", i)) } wg.Wait() } </code></pre></div> <h3 id="real-time-recommendations" class="position-relative d-flex align-items-center group"> Real-Time Recommendations <button type="button" class="h-share btn btn-link p-0 text-decoration-none link-secondary opacity-50 hover-opacity-100 transition-all ms-1" data-share-target="real-time-recommendations" aria-haspopup="dialog" aria-label="Share link: Real-Time Recommendations"> Share link </button> </h3> <h4 id="instant-personalization" class="position-relative d-flex align-items-center group"> Instant Personalization <button type="button" class="h-share btn btn-link p-0 text-decoration-none link-secondary opacity-50 hover-opacity-100 transition-all ms-1" data-share-target="instant-personalization" aria-haspopup="dialog" aria-label="Share link: Instant Personalization"> Share link </button> </h4>Generate recommendations with low latency: <div class="highlight"><pre tabindex="0" class="chroma"><code class="language-gql" data-lang="gql">// Real-time product recommendations (< 10ms typical) MATCH (u:User {user_id: $user_id})-[:PURCHASED|VIEWED]->(interacted:Product) WITH u, interacted ORDER BY interacted.last_interaction DESC LIMIT 10 // Use recent interactions // Find similar products MATCH (interacted)-[:SIMILAR_TO {similarity_score > 0.7}]-(candidate:Product) WHERE NOT (u)-[:PURCHASED]->(candidate) // Not already purchased // Score candidates WITH candidate, COUNT(interacted) AS based_on_count, AVG(similarity_score) AS avg_similarity, candidate.popularity_score AS popularity WITH candidate, (based_on_count * avg_similarity * 0.7 + popularity * 0.3) AS score ORDER BY score DESC LIMIT 20 RETURN candidate.product_id, candidate.name, score; </code></pre></div> <h4 id="contextual-filtering" class="position-relative d-flex align-items-center group"> Contextual Filtering <button type="button" class="h-share btn btn-link p-0 text-decoration-none link-secondary opacity-50 hover-opacity-100 transition-all ms-1" data-share-target="contextual-filtering" aria-haspopup="dialog" aria-label="Share link: Contextual Filtering"> Share link </button> </h4>Apply real-time context to recommendations: <div class="highlight"><pre tabindex="0" class="chroma"><code class="language-gql" data-lang="gql">// Filter recommendations by user's current context MATCH (u:User {user_id: $user_id}) WITH u, $current_location AS location, $time_of_day AS time_hour // Get base recommendations MATCH (u)-[:INTERESTED_IN]->(category:Category) MATCH (category)<-[:IN_CATEGORY]-(p:Product) WHERE NOT (u)-[:PURCHASED]->(p) // Apply contextual filters WITH p, location, time_hour WHERE ( // Location-based availability EXISTS((p)-[:AVAILABLE_IN]->(:Region {name: location})) AND // Time-appropriate products (time_hour BETWEEN 9 AND 21 OR p.available_24_7 = true) AND // In stock p.stock_quantity > 0 ) ORDER BY p.relevance_score DESC LIMIT 10 RETURN p.product_id, p.name, p.price; </code></pre></div> <h3 id="performance-monitoring" class="position-relative d-flex align-items-center group"> Performance Monitoring <button type="button" class="h-share btn btn-link p-0 text-decoration-none link-secondary opacity-50 hover-opacity-100 transition-all ms-1" data-share-target="performance-monitoring" aria-haspopup="dialog" aria-label="Share link: Performance Monitoring"> Share link </button> </h3> <h4 id="query-profiling" class="position-relative d-flex align-items-center group"> Query Profiling <button type="button" class="h-share btn btn-link p-0 text-decoration-none link-secondary opacity-50 hover-opacity-100 transition-all ms-1" data-share-target="query-profiling" aria-haspopup="dialog" aria-label="Share link: Query Profiling"> Share link </button> </h4>Analyze query performance in real-time: <div class="highlight"><pre tabindex="0" class="chroma"><code class="language-gql" data-lang="gql">// Profile query execution PROFILE MATCH (u:User {user_id: $user_id})-[:FOLLOWS*1..2]->(friend:User) WHERE friend.active = true RETURN friend.user_id, friend.name LIMIT 50; // Returns execution plan with timing: // - Index seek: 0.2ms // - Traversal: 1.5ms // - Filter: 0.3ms // - Total: 2.0ms </code></pre></div> <h4 id="real-time-metrics" class="position-relative d-flex align-items-center group"> Real-Time Metrics <button type="button" class="h-share btn btn-link p-0 text-decoration-none link-secondary opacity-50 hover-opacity-100 transition-all ms-1" data-share-target="real-time-metrics" aria-haspopup="dialog" aria-label="Share link: Real-Time Metrics"> Share link </button> </h4>Monitor system performance: <div class="highlight"><pre tabindex="0" class="chroma"><code class="language-gql" data-lang="gql">// Query current system metrics SHOW DATABASE METRICS; // Returns: // - queries_per_second // - avg_query_latency_ms // - active_connections // - cache_hit_rate // - transaction_rate // Track query statistics SHOW QUERY STATISTICS WHERE query_time > datetime().minusMinutes(5) ORDER BY execution_time DESC LIMIT 10; </code></pre></div> <h3 id="best-practices" class="position-relative d-flex align-items-center group"> Best Practices <button type="button" class="h-share btn btn-link p-0 text-decoration-none link-secondary opacity-50 hover-opacity-100 transition-all ms-1" data-share-target="best-practices" aria-haspopup="dialog" aria-label="Share link: Best Practices"> Share link </button> </h3><ol> <li>Use Indexes: Ensure all lookup properties are indexed for constant-time access</li> <li>Limit Result Sets: Always use LIMIT to bound query execution time</li> <li>Bound Traversals: Limit path depths to prevent runaway queries</li> <li>Prepare Statements: Reuse prepared statements for frequently executed queries</li> <li>Connection Pooling: Maintain a pool of connections for concurrent workloads</li> <li>Filter Early: Apply WHERE clauses as early as possible in queries</li> <li>Monitor Latency: Track p50, p95, p99 latency metrics for all query types</li> <li>Batch Updates: Group related writes into transactions for better throughput</li> <li>Async Processing: Use CDC for asynchronous downstream processing</li> <li>Cache Strategically: Cache frequently accessed data at the application layer</li> </ol> <h3 id="integration-with-geode-features" class="position-relative d-flex align-items-center group"> Integration with Geode Features <button type="button" class="h-share btn btn-link p-0 text-decoration-none link-secondary opacity-50 hover-opacity-100 transition-all ms-1" data-share-target="integration-with-geode-features" aria-haspopup="dialog" aria-label="Share link: Integration with Geode Features"> Share link </button> </h3>Real-time processing leverages: <ul> <li>MVCC: Non-blocking concurrent reads and writes</li> <li>QUIC Protocol: Low-latency network transport with multiplexing</li> <li>Indexes: B-tree, HNSW vector, and full-text indexes for fast lookups</li> <li>CDC: Change streams for event-driven architectures</li> <li>Prepared Statements: Reduced parsing overhead for repeated queries</li> <li>Telemetry: Real-time performance metrics via Prometheus</li> </ul> Browse the tagged content below to discover documentation, tutorials, and guides for building real-time graph applications with Geode. <h3 id="real-time-application-architecture" class="position-relative d-flex align-items-center group"> Real-Time Application Architecture <button type="button" class="h-share btn btn-link p-0 text-decoration-none link-secondary opacity-50 hover-opacity-100 transition-all ms-1" data-share-target="real-time-application-architecture" aria-haspopup="dialog" aria-label="Share link: Real-Time Application Architecture"> Share link </button> </h3> <h4 id="event-driven-microservices" class="position-relative d-flex align-items-center group"> Event-Driven Microservices <button type="button" class="h-share btn btn-link p-0 text-decoration-none link-secondary opacity-50 hover-opacity-100 transition-all ms-1" data-share-target="event-driven-microservices" aria-haspopup="dialog" aria-label="Share link: Event-Driven Microservices"> Share link </button> </h4>Build responsive systems with event-driven architecture: <div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python"># Microservice reacting to graph changes in real-time from geode_client import Client, ChangeStreamConsumer import asyncio class OrderProcessingService: def __init__(self, geode_client): self.client = geode_client self.consumer = ChangeStreamConsumer(client, 'order_stream') async def start(self): """Process order events in real-time""" async for change in self.consumer.stream(): if change.event_type == 'CREATED': await self.process_new_order(change.after) elif change.event_type == 'UPDATED': await self.handle_order_update(change.before, change.after) async def process_new_order(self, order): """Handle new order with sub-10ms latency""" # Validate inventory (indexed lookup, <1ms) available, _ = await self.client.query(""" MATCH (p:Product {id: $product_id}) WHERE p.stock_quantity >= $quantity RETURN p.stock_quantity """, {"product_id": order['product_id'], "quantity": order['quantity']}) if available: # Reserve inventory atomically await self.client.execute(""" MATCH (p:Product {id: $product_id}) SET p.stock_quantity = p.stock_quantity - $quantity CREATE (o:Order {id: $order_id, status: 'confirmed'}) CREATE (o)-[:RESERVES]->(p) """, { "product_id": order['product_id'], "quantity": order['quantity'], "order_id": order['id'] }) # Trigger downstream services (payment, shipping) await self.notify_payment_service(order) await self.notify_fulfillment_service(order) </code></pre></div> <h4 id="real-time-dashboard-backend" class="position-relative d-flex align-items-center group"> Real-Time Dashboard Backend <button type="button" class="h-share btn btn-link p-0 text-decoration-none link-secondary opacity-50 hover-opacity-100 transition-all ms-1" data-share-target="real-time-dashboard-backend" aria-haspopup="dialog" aria-label="Share link: Real-Time Dashboard Backend"> Share link </button> </h4>Power live dashboards with streaming queries: <div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python">from fastapi import FastAPI, WebSocket from geode_client import Client app = FastAPI() @app.websocket("/ws/dashboard") async def dashboard_stream(websocket: WebSocket): """Stream real-time metrics to dashboard""" await websocket.accept() client = await Client.connect("localhost:3141") try: while True: # Compute real-time metrics every second metrics = await asyncio.gather( # Active users (last 5 minutes) client.execute(""" MATCH (e:Event {type: 'user_active'}) WHERE e.timestamp > datetime().minusMinutes(5) RETURN COUNT(DISTINCT e.user_id) AS active_users """), # Orders per minute client.execute(""" MATCH (o:Order) WHERE o.created_at > datetime().minusMinutes(1) RETURN COUNT(o) AS orders_per_minute """), # Revenue (last hour) client.execute(""" MATCH (o:Order {status: 'completed'}) WHERE o.completed_at > datetime().minusHours(1) RETURN SUM(o.total) AS revenue_last_hour """), # Top products client.execute(""" MATCH (o:Order)-[:CONTAINS]->(p:Product) WHERE o.created_at > datetime().minusHours(1) RETURN p.name, COUNT(o) AS orders ORDER BY orders DESC LIMIT 5 """) ) # Send to WebSocket (< 20ms total latency) await websocket.send_json({ "timestamp": datetime.now().isoformat(), "active_users": metrics[0].bindings[0]['active_users'], "orders_per_minute": metrics[1].bindings[0]['orders_per_minute'], "revenue_last_hour": metrics[2].bindings[0]['revenue_last_hour'], "top_products": metrics[3].bindings }) await asyncio.sleep(1) # Update every second finally: await client.close() </code></pre></div> <h4 id="live-recommendation-engine" class="position-relative d-flex align-items-center group"> Live Recommendation Engine <button type="button" class="h-share btn btn-link p-0 text-decoration-none link-secondary opacity-50 hover-opacity-100 transition-all ms-1" data-share-target="live-recommendation-engine" aria-haspopup="dialog" aria-label="Share link: Live Recommendation Engine"> Share link </button> </h4>Generate personalized recommendations with <10ms latency: <div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python">class RecommendationEngine: def __init__(self, client): self.client = client # Prepare frequently-used queries self.similar_products_stmt = None async def initialize(self): """Prepare statements for faster execution""" self.similar_products_stmt = await self.client.prepare(""" MATCH (viewed:Product {id: $product_id})-[:SIMILAR_TO]-(similar:Product) WHERE similar.in_stock = true AND NOT EXISTS { MATCH (u:User {id: $user_id})-[:PURCHASED]->(similar) } WITH similar, similar.popularity_score AS popularity, COUNT{(similar)<-[:PURCHASED]-(:User)} AS purchase_count RETURN similar.id AS product_id, similar.name AS name, similar.price AS price, (popularity * 0.3 + purchase_count * 0.7) AS score ORDER BY score DESC LIMIT $limit """) async def get_recommendations(self, user_id, context): """Real-time recommendations with <5ms latency""" # Use prepared statement for hot path recommendations, _ = await self.similar_products_stmt.execute({ "user_id": user_id, "product_id": context['current_product_id'], "limit": 20 }) # Apply real-time personalization filters filtered = await self._apply_user_preferences( user_id, recommendations.rows ) return filtered async def _apply_user_preferences(self, user_id, candidates): """Filter by user preferences (cached, <1ms)""" # User preferences cached in-memory or Redis prefs = await self.get_user_preferences(user_id) return [ rec for rec in candidates if rec['price'] <= prefs['max_price'] and rec['category'] in prefs['preferred_categories'] ] </code></pre></div> <h3 id="real-time-analytics-patterns" class="position-relative d-flex align-items-center group"> Real-Time Analytics Patterns <button type="button" class="h-share btn btn-link p-0 text-decoration-none link-secondary opacity-50 hover-opacity-100 transition-all ms-1" data-share-target="real-time-analytics-patterns" aria-haspopup="dialog" aria-label="Share link: Real-Time Analytics Patterns"> Share link </button> </h3> <h4 id="sliding-time-windows" class="position-relative d-flex align-items-center group"> Sliding Time Windows <button type="button" class="h-share btn btn-link p-0 text-decoration-none link-secondary opacity-50 hover-opacity-100 transition-all ms-1" data-share-target="sliding-time-windows" aria-haspopup="dialog" aria-label="Share link: Sliding Time Windows"> Share link </button> </h4>Compute metrics over rolling time windows: <div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python">async def compute_rolling_metrics(): """Calculate metrics over sliding windows""" client = await Client.connect("localhost:3141") # 5-minute rolling average of response times result, _ = await client.query(""" MATCH (req:Request) WHERE req.timestamp > datetime().minusMinutes(5) WITH req.timestamp AS ts, req.duration_ms AS duration ORDER BY ts WITH collect({ts: ts, duration: duration}) AS samples UNWIND range(0, SIZE(samples) - 1) AS i WITH samples[i].ts AS timestamp, [x IN samples[i..i+59] | x.duration] AS window RETURN timestamp, AVG(window) AS avg_response_time, PERCENTILE_CONT(window, 0.95) AS p95_response_time """) for row in result.bindings: print(f"{row['timestamp']}: avg={row['avg_response_time']}ms, " f"p95={row['p95_response_time']}ms") </code></pre></div> <h4 id="real-time-anomaly-detection" class="position-relative d-flex align-items-center group"> Real-Time Anomaly Detection <button type="button" class="h-share btn btn-link p-0 text-decoration-none link-secondary opacity-50 hover-opacity-100 transition-all ms-1" data-share-target="real-time-anomaly-detection" aria-haspopup="dialog" aria-label="Share link: Real-Time Anomaly Detection"> Share link </button> </h4>Detect anomalies as they occur: <div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python">async def detect_anomalies(): """Real-time anomaly detection on graph patterns""" client = await Client.connect("localhost:3141") # Detect unusual user behavior patterns anomalies, _ = await client.query(""" MATCH (u:User)-[a:ACTION]->(resource) WHERE a.timestamp > datetime().minusMinutes(5) WITH u, COUNT(a) AS action_count, COUNT(DISTINCT resource) AS unique_resources, AVG(a.duration_ms) AS avg_duration WHERE action_count > 100 -- Unusually high activity OR unique_resources > 50 -- Accessing many resources OR avg_duration < 10 -- Suspiciously fast RETURN u.id, action_count, unique_resources, avg_duration, 'potential_bot' AS anomaly_type """) for anomaly in anomalies.bindings: await alert_security_team(anomaly) await throttle_user(anomaly['u.id']) </code></pre></div> <h4 id="stream-joins" class="position-relative d-flex align-items-center group"> Stream Joins <button type="button" class="h-share btn btn-link p-0 text-decoration-none link-secondary opacity-50 hover-opacity-100 transition-all ms-1" data-share-target="stream-joins" aria-haspopup="dialog" aria-label="Share link: Stream Joins"> Share link </button> </h4>Join real-time event streams with graph data: <div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python">async def join_streams_with_graph(): """Enrich event stream with graph context""" # Event stream from Kafka/Kinesis event_stream = KafkaConsumer('user-events') client = await Client.connect("localhost:3141") async for event in event_stream: # Enrich event with user graph context context, _ = await client.query(""" MATCH (u:User {id: $user_id}) OPTIONAL MATCH (u)-[:FRIEND]->(friend:User) OPTIONAL MATCH (u)-[:MEMBER_OF]->(group:Group) RETURN u.name, u.tier, COUNT(friend) AS friend_count, COLLECT(group.name) AS groups """, {"user_id": event['user_id']}) enriched_event = { **event, "user_context": context.bindings[0] } # Forward to downstream processing await process_enriched_event(enriched_event) </code></pre></div> <h3 id="optimization-techniques" class="position-relative d-flex align-items-center group"> Optimization Techniques <button type="button" class="h-share btn btn-link p-0 text-decoration-none link-secondary opacity-50 hover-opacity-100 transition-all ms-1" data-share-target="optimization-techniques" aria-haspopup="dialog" aria-label="Share link: Optimization Techniques"> Share link </button> </h3> <h4 id="index-optimized-queries" class="position-relative d-flex align-items-center group"> Index-Optimized Queries <button type="button" class="h-share btn btn-link p-0 text-decoration-none link-secondary opacity-50 hover-opacity-100 transition-all ms-1" data-share-target="index-optimized-queries" aria-haspopup="dialog" aria-label="Share link: Index-Optimized Queries"> Share link </button> </h4>Ensure queries use indexes for consistent low latency: <div class="highlight"><pre tabindex="0" class="chroma"><code class="language-gql" data-lang="gql">-- Create indexes on lookup properties CREATE INDEX FOR (u:User) ON (u.id); CREATE INDEX FOR (u:User) ON (u.email); CREATE INDEX FOR (p:Product) ON (p.sku); CREATE INDEX FOR (e:Event) ON (e.timestamp); -- Compound index for multi-property lookups CREATE INDEX FOR (o:Order) ON (o.user_id, o.status); -- Verify index usage with EXPLAIN EXPLAIN MATCH (u:User {email: $email}) RETURN u; -- Should show: IndexScan (user_email_idx) -- Queries using indexes have predictable latency MATCH (u:User {email: 'alice@example.com'}) -- <1ms RETURN u; MATCH (u:User {id: 12345}) -- <1ms RETURN u; MATCH (o:Order {user_id: 12345, status: 'pending'}) -- <2ms RETURN o; </code></pre></div> <h4 id="connection-pooling-for-high-throughput" class="position-relative d-flex align-items-center group"> Connection Pooling for High Throughput <button type="button" class="h-share btn btn-link p-0 text-decoration-none link-secondary opacity-50 hover-opacity-100 transition-all ms-1" data-share-target="connection-pooling-for-high-throughput" aria-haspopup="dialog" aria-label="Share link: Connection Pooling for High Throughput"> Share link </button> </h4>Optimize connection management for concurrent workloads: <div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python">from geode_client import ConnectionPool # Configure pool for real-time workload pool = ConnectionPool( host="localhost", port=3141, min_connections=20, # Always ready max_connections=200, # Scale under load connection_timeout=5, # Fail fast idle_timeout=300, # Reap idle connections health_check_interval=60 # Verify connection health ) async def handle_request(user_id): """Process request with pooled connection""" async with pool.acquire() as client: # Connection acquired from pool (no handshake overhead) result, _ = await client.query(""" MATCH (u:User {id: $user_id})-[:RECENT]->(items) RETURN items LIMIT 10 """, {"user_id": user_id}) return result.bindings # Concurrent request handling async def main(): requests = [handle_request(i) for i in range(10000)] results = await asyncio.gather(*requests) # Pool manages connection allocation efficiently </code></pre></div> <h4 id="query-result-caching" class="position-relative d-flex align-items-center group"> Query Result Caching <button type="button" class="h-share btn btn-link p-0 text-decoration-none link-secondary opacity-50 hover-opacity-100 transition-all ms-1" data-share-target="query-result-caching" aria-haspopup="dialog" aria-label="Share link: Query Result Caching"> Share link </button> </h4>Cache frequently accessed data at application layer: <div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python">import asyncio from cachetools import TTLCache class CachedClient: def __init__(self, client): self.client = client # TTL cache: 1000 entries, 60-second TTL self.cache = TTLCache(maxsize=1000, ttl=60) async def get_user(self, user_id): """Get user with caching""" cache_key = f"user:{user_id}" if cache_key in self.cache: return self.cache[cache_key] # Cache hit (<0.1ms) # Cache miss - query database result, _ = await self.client.query(""" MATCH (u:User {id: $id}) RETURN u """, {"id": user_id}) user = result.bindings[0] if result.bindings else None self.cache[cache_key] = user return user async def invalidate_user(self, user_id): """Invalidate cache on updates""" cache_key = f"user:{user_id}" self.cache.pop(cache_key, None) </code></pre></div> <h3 id="production-deployment" class="position-relative d-flex align-items-center group"> Production Deployment <button type="button" class="h-share btn btn-link p-0 text-decoration-none link-secondary opacity-50 hover-opacity-100 transition-all ms-1" data-share-target="production-deployment" aria-haspopup="dialog" aria-label="Share link: Production Deployment"> Share link </button> </h3> <h4 id="load-balancing" class="position-relative d-flex align-items-center group"> Load Balancing <button type="button" class="h-share btn btn-link p-0 text-decoration-none link-secondary opacity-50 hover-opacity-100 transition-all ms-1" data-share-target="load-balancing" aria-haspopup="dialog" aria-label="Share link: Load Balancing"> Share link </button> </h4>Distribute real-time queries across replicas: <div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python">from geode_client import LoadBalancedClient # Connect to multiple Geode nodes client = LoadBalancedClient( nodes=[ "node1.example.com:3141", "node2.example.com:3141", "node3.example.com:3141" ], strategy="least_loaded", # Route to least loaded node health_check_interval=30 # Check node health every 30s ) # Queries automatically distributed async def query_with_lb(): # Routes to healthy, least-loaded node result, _ = await client.query("MATCH (u:User) RETURN count(u)") </code></pre></div> <h4 id="monitoring-real-time-performance" class="position-relative d-flex align-items-center group"> Monitoring Real-Time Performance <button type="button" class="h-share btn btn-link p-0 text-decoration-none link-secondary opacity-50 hover-opacity-100 transition-all ms-1" data-share-target="monitoring-real-time-performance" aria-haspopup="dialog" aria-label="Share link: Monitoring Real-Time Performance"> Share link </button> </h4>Track real-time query performance: <div class="highlight"><pre tabindex="0" class="chroma"><code class="language-python" data-lang="python">from prometheus_client import Histogram, Counter # Metrics query_duration = Histogram('geode_query_duration_seconds', 'Query execution time') query_errors = Counter('geode_query_errors_total', 'Total query errors') async def execute_with_metrics(client, query, params): """Execute query with performance tracking""" with query_duration.time(): try: result, _ = await client.query(query, params) return result except Exception as e: query_errors.inc() raise # Grafana dashboard queries Prometheus metrics: # - P50, P95, P99 latency # - QPS (queries per second) # - Error rate </code></pre></div>Browse the tagged content below to discover documentation, tutorials, and guides for building real-time graph applications with Geode.

Popular

Related Articles

Analytics