{"passport":{"unfragile":{"@version":"1.0","version":"2026-05","artifact":{"id":"github-oceanbase--oceanbase","slug":"oceanbase--oceanbase","name":"oceanbase","type":"product","url":"https://en.oceanbase.com","page_url":"https://unfragile.ai/oceanbase--oceanbase","categories":["data-pipelines"],"tags":["analytics","cloud-native","database","distributed-database","fulltext","fulltext-search","fulltext-support","hacktoberfest","htap","mysql","mysql-compatibility","oceanbase","olap","oltp","paxos","scalable","vector","vector-database","vector-search","vectors"],"pricing":{"model":"open_source","free":true,"starting_price":null},"status":"active","verified":false},"capabilities":[{"id":"github-oceanbase--oceanbase__cap_0","uri":"capability://data.processing.analysis.mysql.compatible.sql.query.parsing.and.resolution","name":"mysql-compatible sql query parsing and resolution","description":"Parses SQL statements using a recursive descent parser that builds an abstract syntax tree (AST), then resolves table references, column names, and function calls against the internal schema system. The resolver validates semantic correctness by cross-referencing the internal table schema (ob_inner_table_schema) and type system before passing to the optimizer. Supports MySQL 5.7+ syntax including window functions, CTEs, and subqueries.","intents":["Execute MySQL-compatible SQL queries without rewriting application code","Validate SQL syntax and semantic correctness before execution","Support legacy MySQL applications migrating to a distributed database"],"best_for":["Teams migrating from MySQL to distributed OLTP/OLAP workloads","Applications requiring strict MySQL syntax compatibility"],"limitations":["Parser does not support MySQL 8.0+ JSON path expressions in all contexts","Some MySQL-specific functions (e.g., LOAD_FILE) are not implemented","Parsing latency increases with query complexity and deeply nested subqueries"],"requires":["Valid SQL statement conforming to MySQL 5.7+ grammar","Schema metadata loaded in internal table schema system"],"input_types":["SQL text (SELECT, INSERT, UPDATE, DELETE, DDL statements)"],"output_types":["Parsed AST with resolved table/column references","Semantic validation errors or warnings"],"categories":["data-processing-analysis","sql-parsing"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-oceanbase--oceanbase__cap_1","uri":"capability://planning.reasoning.cost.based.query.optimization.with.multi.table.join.planning","name":"cost-based query optimization with multi-table join planning","description":"Applies cost-based optimization using cardinality estimation, table statistics, and join order enumeration to generate optimal physical execution plans. The optimizer evaluates multiple join orders (nested loop, hash join, merge join) and access paths (full scan, index scan, partition pruning) using a dynamic programming algorithm. Integrates with the plan cache to avoid re-optimization for identical query patterns.","intents":["Minimize query execution time by choosing optimal join orders and access paths","Leverage table statistics to make data-driven optimization decisions","Cache optimized plans to reduce compilation overhead for repeated queries"],"best_for":["OLTP workloads with complex multi-table joins","OLAP queries on large datasets where join order is critical","Applications with stable query patterns that benefit from plan caching"],"limitations":["Optimizer assumes statistics are up-to-date; stale statistics lead to suboptimal plans","Dynamic programming enumeration can timeout on queries with >10 tables","Cardinality estimation errors compound across multiple joins, reducing plan quality","Plan cache invalidation on schema changes may cause temporary performance degradation"],"requires":["Table statistics (row count, column histograms) collected via ANALYZE TABLE","Multi-table join query with resolvable table references"],"input_types":["Parsed and resolved SQL query AST"],"output_types":["Physical execution plan with join order, access methods, and cost estimates","Plan cache entry for future reuse"],"categories":["planning-reasoning","query-optimization"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-oceanbase--oceanbase__cap_10","uri":"capability://automation.workflow.distributed.transaction.coordination.with.two.phase.commit","name":"distributed transaction coordination with two-phase commit","description":"Coordinates multi-tablet transactions using a two-phase commit (2PC) protocol where the transaction coordinator (typically the leader tablet) collects prepare votes from all participating tablets, then issues a global commit or rollback decision. The protocol uses write-ahead logging to ensure durability of the commit decision, and Paxos replication to ensure the decision survives coordinator failures. Supports both strong consistency (all-or-nothing) and eventual consistency modes for performance tuning.","intents":["Ensure ACID guarantees for transactions spanning multiple partitions","Prevent partial updates across distributed data","Coordinate commits across replicas safely"],"best_for":["Financial systems requiring strict ACID guarantees","Multi-partition transactions with consistency requirements","Applications where data corruption from partial commits is unacceptable"],"limitations":["2PC adds 20-50% latency overhead compared to single-partition transactions due to prepare phase","Coordinator failures can cause transaction blocking until timeout (typically 30-60 seconds)","Deadlocks across partitions are not automatically detected; applications must implement retry logic","Prepare phase requires all participants to be reachable; network partitions cause transaction timeouts"],"requires":["All participating tablets must be reachable and responsive","Write-ahead log (WAL) for durability of commit decisions","Transaction timeout configured (typically 30-60 seconds)"],"input_types":["Multi-partition transaction with read/write operations"],"output_types":["Commit or rollback decision propagated to all participants","Transaction status (committed, rolled back, or timed out)"],"categories":["automation-workflow","transaction-coordination"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-oceanbase--oceanbase__cap_11","uri":"capability://planning.reasoning.partition.pruning.and.predicate.pushdown.for.query.optimization","name":"partition pruning and predicate pushdown for query optimization","description":"Analyzes WHERE clause predicates during query optimization to identify which tablet partitions contain matching rows, then prunes partitions that cannot contain results. Pushes filter predicates down to the storage layer so that filtering happens during table scans rather than after rows are retrieved. Supports range pruning (for range-partitioned tables), hash pruning (for hash-partitioned tables), and list pruning (for list-partitioned tables). Integrates with the query optimizer to apply pruning before generating the execution plan.","intents":["Reduce query latency by scanning fewer partitions","Lower network traffic by filtering data at the source","Improve resource utilization by avoiding unnecessary tablet access"],"best_for":["Large tables partitioned by date or ID with time-range or ID-range queries","Multi-tenant systems where queries are filtered by tenant ID","Analytical queries on partitioned fact tables"],"limitations":["Pruning effectiveness depends on partition key alignment with query predicates; misaligned keys provide no benefit","Complex predicates (e.g., OR conditions across multiple columns) may prevent pruning","Partition metadata must be up-to-date; stale metadata can cause incorrect pruning","Dynamic predicates (e.g., subquery results) cannot be pruned at plan time; pruning happens at runtime with overhead"],"requires":["Table partitioned by a column that aligns with query predicates","Partition key information available in table metadata"],"input_types":["Query with WHERE clause predicates"],"output_types":["Pruned partition list","Execution plan with partition-specific scans"],"categories":["planning-reasoning","query-optimization"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-oceanbase--oceanbase__cap_12","uri":"capability://planning.reasoning.adaptive.query.execution.with.runtime.statistics.collection","name":"adaptive query execution with runtime statistics collection","description":"Collects runtime statistics during query execution (rows processed, actual join cardinalities, predicate selectivity) and uses these statistics to adapt the execution plan mid-query. If actual cardinalities differ significantly from estimates, the executor can switch to a different join algorithm or access path without restarting the query. Statistics are fed back to the plan cache to improve future plan quality. Integrates with the SQL audit system (ob_gv_sql_audit) to track execution metrics.","intents":["Improve query performance when cardinality estimates are inaccurate","Adapt execution strategy based on actual data distribution","Collect feedback for plan cache optimization"],"best_for":["Queries with highly variable data distributions","Workloads where cardinality estimation is frequently wrong","Systems where plan quality feedback is critical for performance"],"limitations":["Runtime adaptation adds 5-10% overhead per query due to statistics collection","Switching join algorithms mid-query requires buffering intermediate results, increasing memory usage","Adaptation decisions are heuristic-based; no guarantee of optimal plan selection","Statistics collection adds latency to every query; high-frequency queries may see noticeable slowdown"],"requires":["SQL audit system enabled to collect execution metrics","Plan cache with feedback mechanism"],"input_types":["Query execution with runtime cardinality information"],"output_types":["Adapted execution plan","Runtime statistics for plan cache feedback"],"categories":["planning-reasoning","adaptive-execution"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-oceanbase--oceanbase__cap_13","uri":"capability://safety.moderation.tenant.isolation.with.resource.quotas.and.multi.tenancy.support","name":"tenant isolation with resource quotas and multi-tenancy support","description":"Isolates multiple tenants within a single OceanBase cluster using logical tenant boundaries, resource quotas (CPU, memory, I/O), and access control lists. Each tenant has its own schema, data, and configuration, but shares underlying hardware resources. The resource manager enforces quotas by throttling queries that exceed allocated resources. Integrates with the session context to track tenant identity and apply tenant-specific configuration.","intents":["Host multiple independent applications in a single database cluster","Enforce resource isolation to prevent one tenant from impacting others","Simplify multi-tenant application deployment and management"],"best_for":["SaaS platforms serving multiple customers","Cloud database services with multi-tenant requirements","Enterprises consolidating multiple applications into a single cluster"],"limitations":["Resource quota enforcement adds 5-15% overhead due to quota checking on every query","Quota limits are coarse-grained (CPU, memory, I/O); fine-grained per-query limits are not supported","Tenant isolation is logical, not physical; determined tenants can potentially access other tenant data through SQL injection","Resource contention between tenants can cause unpredictable latency spikes"],"requires":["Tenant configuration with resource quotas","Access control lists defining tenant permissions"],"input_types":["Tenant identity (tenant_id) in session context","Query with resource consumption estimates"],"output_types":["Query execution with resource quota enforcement","Resource usage metrics per tenant"],"categories":["safety-moderation","multi-tenancy"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-oceanbase--oceanbase__cap_2","uri":"capability://automation.workflow.distributed.sql.execution.with.tablet.aware.data.routing","name":"distributed sql execution with tablet-aware data routing","description":"Executes physical plans across multiple tablet replicas by decomposing queries into remote RPC calls via the RPC communication framework. The executor routes data requests to the correct tablet partition based on the partition key, handles remote execution failures with automatic retry logic, and merges results from multiple tablets. Uses the ObRpcProcessor framework to serialize/deserialize query fragments and coordinate execution across nodes.","intents":["Execute queries that span multiple partitions without application-level sharding logic","Transparently distribute query execution across cluster nodes","Handle tablet replica failures and network partitions gracefully"],"best_for":["Distributed OLTP applications requiring transparent data partitioning","Multi-tenant systems where data isolation is enforced at the tablet level","Clusters with 3+ nodes where query distribution is essential for performance"],"limitations":["Cross-tablet joins require data shuffling, adding network latency (typically 10-50ms per shuffle)","Retry logic can cause query timeouts if tablet replicas are unavailable for >30 seconds","RPC serialization overhead adds ~5-10% latency compared to local execution","Distributed deadlock detection is not fully implemented; circular waits may cause hangs"],"requires":["Cluster with 3+ nodes running OceanBase observer processes","Tablets properly replicated across nodes using Paxos consensus","Network connectivity between all nodes with <100ms latency"],"input_types":["Physical execution plan with tablet partition information"],"output_types":["Result set merged from multiple tablet replicas","Execution statistics (rows processed, RPC latency, remote execution time)"],"categories":["automation-workflow","distributed-execution"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-oceanbase--oceanbase__cap_3","uri":"capability://data.processing.analysis.mvcc.based.snapshot.isolation.with.multi.version.row.storage","name":"mvcc-based snapshot isolation with multi-version row storage","description":"Implements multi-version concurrency control (MVCC) using row-level versioning where each row modification creates a new version with a transaction ID (txn_id) and commit timestamp. Readers acquire a consistent snapshot at a specific timestamp and only see versions committed before that timestamp, enabling concurrent reads and writes without blocking. The transaction manager maintains active transaction lists and coordinates version visibility across the cluster using the Paxos consensus protocol.","intents":["Support concurrent reads and writes without locking contention","Provide snapshot isolation guarantees for consistent reads","Enable time-travel queries to read historical data at specific timestamps"],"best_for":["High-concurrency OLTP workloads with many concurrent readers and writers","Applications requiring consistent snapshots across distributed nodes","Audit and compliance scenarios requiring historical data access"],"limitations":["Garbage collection of old versions adds background overhead; aggressive GC can cause read latency spikes","Long-running transactions prevent version cleanup, causing storage bloat (can exceed 2x normal size)","Snapshot isolation does not prevent phantom reads; applications must use serializable isolation for stronger guarantees","Version visibility checks add ~2-5% CPU overhead per row read compared to single-version storage"],"requires":["Transaction manager initialized with active transaction tracking","Paxos consensus protocol for timestamp ordering across nodes","Sufficient storage for multiple row versions (typically 1.5-3x base data size)"],"input_types":["Read/write operations with transaction context (txn_id, snapshot_timestamp)"],"output_types":["Visible row versions matching the snapshot timestamp","Version metadata (txn_id, commit_ts, undo_log pointers)"],"categories":["data-processing-analysis","transaction-management"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-oceanbase--oceanbase__cap_4","uri":"capability://automation.workflow.paxos.based.distributed.consensus.for.tablet.replication","name":"paxos-based distributed consensus for tablet replication","description":"Replicates tablet data across multiple nodes using the Paxos consensus protocol, ensuring that writes are committed only after a quorum of replicas acknowledge the change. The leader replica coordinates write proposals, followers apply changes in log order, and the protocol handles leader failures by triggering new elections. Integrates with the tablet management system to track replica locations and membership changes.","intents":["Ensure data durability across node failures without losing committed data","Maintain consistency across distributed replicas without manual failover","Support automatic leader election when the primary replica fails"],"best_for":["Production clusters requiring high availability and data durability","Multi-region deployments where data must survive single-node failures","Applications with strict consistency requirements (no eventual consistency)"],"limitations":["Paxos requires a quorum (typically 3 nodes minimum); clusters with <3 nodes cannot tolerate failures","Write latency increases with replica count due to quorum acknowledgment waits (typically +5-10ms per additional replica)","Network partitions can cause leader election storms if not properly configured with heartbeat timeouts","Membership changes (adding/removing replicas) require a two-phase protocol and can block writes for 10-30 seconds"],"requires":["Minimum 3 nodes for quorum-based replication","Reliable network with <100ms latency between replicas","Persistent write-ahead log (WAL) on each replica"],"input_types":["Write operations with transaction context","Membership change requests (add/remove replica)"],"output_types":["Commit confirmation after quorum acknowledgment","Replica synchronization status and lag metrics"],"categories":["automation-workflow","consensus-protocol"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-oceanbase--oceanbase__cap_5","uri":"capability://search.retrieval.full.text.search.indexing.and.query.execution","name":"full-text search indexing and query execution","description":"Builds inverted indexes on text columns that map terms to row IDs, supporting phrase queries, boolean operators, and relevance ranking. The indexing system tokenizes text during INSERT/UPDATE operations and stores term frequencies for BM25 ranking. Query execution uses the inverted index to quickly locate matching rows, then applies ranking functions to order results by relevance. Integrates with the DDL system to support CREATE FULLTEXT INDEX statements.","intents":["Search large text columns efficiently without full table scans","Rank search results by relevance using BM25 or TF-IDF scoring","Support complex text queries (phrases, boolean operators) in SQL"],"best_for":["Content management systems with large document collections","E-commerce platforms requiring product search functionality","Applications with text-heavy data requiring fast keyword matching"],"limitations":["Inverted index maintenance adds 10-20% overhead to INSERT/UPDATE operations on indexed columns","Index size typically 20-40% of the original text data size","Phrase queries require additional position information, increasing index size by 30-50%","Relevance ranking is not customizable; only BM25 is supported natively"],"requires":["Text column with sufficient data to justify index overhead (typically >100K rows)","CREATE FULLTEXT INDEX privilege on the table"],"input_types":["Text data for indexing (INSERT/UPDATE operations)","Full-text search queries with MATCH() function"],"output_types":["Inverted index structure (term → row ID mappings)","Ranked result set with relevance scores"],"categories":["search-retrieval","text-indexing"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-oceanbase--oceanbase__cap_6","uri":"capability://search.retrieval.vector.similarity.search.with.approximate.nearest.neighbor.indexing","name":"vector similarity search with approximate nearest neighbor indexing","description":"Stores dense vector embeddings and supports approximate nearest neighbor (ANN) search using hierarchical navigable small-world (HNSW) or product quantization indexes. The vector engine computes similarity metrics (L2, cosine, inner product) and returns the K nearest neighbors ranked by distance. Integrates with the storage engine to support vector columns and with the query optimizer to push vector distance calculations into the execution plan.","intents":["Find semantically similar items using pre-computed embeddings","Support AI/ML applications requiring vector similarity search","Combine vector search with traditional SQL filters in a single query"],"best_for":["AI-powered recommendation systems","Semantic search applications using LLM embeddings","Hybrid search combining vector similarity with keyword matching"],"limitations":["HNSW index construction time is O(n log n) and can take hours for >10M vectors","Approximate search introduces recall loss; typical recall is 95-99% depending on index parameters","Vector columns require fixed dimensionality; dynamic dimension changes require index rebuild","Memory overhead for HNSW indexes is 8-16 bytes per vector plus graph structure (~50 bytes per vector)"],"requires":["Vector column with fixed dimension (e.g., VECTOR(1536) for OpenAI embeddings)","Pre-computed embeddings from external ML service or model"],"input_types":["Vector embeddings (float arrays of fixed dimension)","Query vectors and similarity metric (L2, cosine, inner product)"],"output_types":["K nearest neighbors with similarity scores","Result set merged with traditional SQL results"],"categories":["search-retrieval","vector-indexing"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-oceanbase--oceanbase__cap_7","uri":"capability://code.generation.editing.pl.sql.stored.procedure.compilation.and.execution","name":"pl/sql stored procedure compilation and execution","description":"Compiles PL/SQL procedures, functions, and packages into bytecode using the PL/SQL compiler (ob_pl_compile), then executes the bytecode in a virtual machine. The compiler performs syntax checking, type resolution, and code generation, storing compiled code in the package manager. Execution supports control flow (loops, conditionals), cursor operations, and calls to SQL statements and built-in packages (DBMS_SQL, DBMS_OUTPUT). Integrates with the session context to maintain procedure state and variable bindings.","intents":["Execute complex business logic in the database without round-trips to the application","Reuse PL/SQL code from Oracle migrations without modification","Implement triggers and stored procedures for data validation and automation"],"best_for":["Applications migrating from Oracle with extensive PL/SQL code","Data-intensive operations requiring procedural logic (ETL, batch processing)","Scenarios where reducing application-database round-trips is critical"],"limitations":["PL/SQL execution is single-threaded per session; parallelization requires multiple sessions","Cursor operations are slower than native SQL due to bytecode interpretation overhead (~2-5x slower)","Package state is session-local; sharing state across sessions requires external storage","Debugging support is limited; no built-in debugger or step-through execution"],"requires":["PL/SQL code conforming to Oracle PL/SQL syntax (subset supported)","CREATE PROCEDURE or CREATE FUNCTION privilege"],"input_types":["PL/SQL source code (procedures, functions, packages)","Procedure parameters and session variables"],"output_types":["Compiled bytecode stored in package manager","Procedure execution results and OUT parameters"],"categories":["code-generation-editing","plsql-execution"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-oceanbase--oceanbase__cap_8","uri":"capability://automation.workflow.schema.evolution.with.online.ddl.and.zero.copy.column.addition","name":"schema evolution with online ddl and zero-copy column addition","description":"Executes DDL operations (CREATE TABLE, ALTER TABLE, DROP TABLE) without blocking concurrent reads and writes using the DDL task scheduler. For column additions, uses a zero-copy approach where new columns are added to the schema metadata without rewriting existing rows; old rows lazily populate default values on read. The DDL service coordinates schema changes across all replicas using Paxos consensus, ensuring consistency. Supports online index creation and constraint addition without table locks.","intents":["Add columns to large tables without downtime or performance degradation","Modify table structure while serving production traffic","Coordinate schema changes across distributed replicas safely"],"best_for":["Production systems requiring zero-downtime schema migrations","Large tables (>100GB) where traditional ALTER TABLE would cause extended locks","Multi-tenant systems where schema changes must be coordinated across tenants"],"limitations":["Zero-copy column addition only works for columns with default values; non-default columns require full table rewrite","Concurrent DDL operations on the same table are serialized; multiple DDLs queue and execute sequentially","Schema change propagation across replicas can take 10-30 seconds; queries may see stale schema briefly","Dropping columns requires a full table rewrite and can take hours for large tables"],"requires":["DDL task scheduler running on the root server","Paxos consensus for schema version coordination","Sufficient disk space for temporary tables during rewrite operations"],"input_types":["DDL statements (ALTER TABLE, CREATE INDEX, etc.)"],"output_types":["Updated schema metadata","DDL execution status and progress tracking"],"categories":["automation-workflow","schema-management"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-oceanbase--oceanbase__cap_9","uri":"capability://data.processing.analysis.hybrid.oltp.olap.workload.support.with.row.and.column.storage","name":"hybrid oltp/olap workload support with row and column storage","description":"Supports both row-oriented storage (for OLTP) and column-oriented storage (for OLAP) within the same database, allowing users to choose the optimal format per table. Row storage uses B+ trees for fast single-row lookups and updates; column storage uses compressed columnar format for fast analytical scans. The query optimizer automatically selects the appropriate storage format based on the query pattern (single-row vs. full-scan). Integrates with the tablet management system to store row and column data in separate tablet replicas.","intents":["Run transactional and analytical queries on the same dataset without ETL","Optimize storage and query performance for mixed OLTP/OLAP workloads","Avoid maintaining separate OLTP and data warehouse systems"],"best_for":["Real-time analytics platforms requiring fresh data","Enterprises consolidating OLTP and data warehouse systems","Applications with unpredictable query patterns (mix of point lookups and scans)"],"limitations":["Column storage adds 10-20% write latency due to columnar encoding overhead","Maintaining both row and column replicas doubles storage requirements","Column storage is not suitable for tables with frequent updates; best for append-only or batch-updated tables","Query optimizer may choose suboptimal storage format if statistics are stale"],"requires":["Sufficient storage for both row and column replicas (2-3x base data size)","Cluster with 6+ nodes to maintain quorum for both storage formats"],"input_types":["Mixed OLTP and OLAP queries","Table creation with storage format specification (ROW or COLUMN)"],"output_types":["Query results from optimal storage format","Storage format selection decisions in query plans"],"categories":["data-processing-analysis","storage-optimization"],"confidence":0.5,"matches":0,"success_rate":0}],"trust":{"score":36,"verified":false,"data_access_risk":"high","permissions":["Valid SQL statement conforming to MySQL 5.7+ grammar","Schema metadata loaded in internal table schema system","Table statistics (row count, column histograms) collected via ANALYZE TABLE","Multi-table join query with resolvable table references","All participating tablets must be reachable and responsive","Write-ahead log (WAL) for durability of commit decisions","Transaction timeout configured (typically 30-60 seconds)","Table partitioned by a column that aligns with query predicates","Partition key information available in table metadata","SQL audit system enabled to collect execution metrics"],"failure_modes":["Parser does not support MySQL 8.0+ JSON path expressions in all contexts","Some MySQL-specific functions (e.g., LOAD_FILE) are not implemented","Parsing latency increases with query complexity and deeply nested subqueries","Optimizer assumes statistics are up-to-date; stale statistics lead to suboptimal plans","Dynamic programming enumeration can timeout on queries with >10 tables","Cardinality estimation errors compound across multiple joins, reducing plan quality","Plan cache invalidation on schema changes may cause temporary performance degradation","2PC adds 20-50% latency overhead compared to single-partition transactions due to prepare phase","Coordinator failures can cause transaction blocking until timeout (typically 30-60 seconds)","Deadlocks across partitions are not automatically detected; applications must implement retry logic","builder identity is not verified yet","no observed match outcomes yet"],"rank_breakdown":{"adoption":0.3491960154420297,"quality":0.35,"ecosystem":0.6000000000000001,"match_graph":0.25,"freshness":0.75,"weights":{"adoption":0.25,"quality":0.25,"ecosystem":0.1,"match_graph":0.35,"freshness":0.05}},"observed_outcomes":{"matches":0,"success_rate":0,"avg_confidence":0,"top_intents":[],"last_matched_at":null},"maintenance":{"status":"active","updated_at":"2026-05-24T12:16:22.063Z","last_scraped_at":"2026-05-03T13:58:32.037Z","last_commit":"2026-05-01T01:01:17Z"},"community":{"stars":10088,"forks":1887,"weekly_downloads":null,"model_downloads":null,"model_likes":null}},"distribution":{"claim_url":"https://unfragile.ai/submit?claim=oceanbase--oceanbase","compare_url":"https://unfragile.ai/compare?artifact=oceanbase--oceanbase"}},"signature":"TSqItKMKvEiCRkZT9aHB/GAibQNjlI8CZaDA7QoDTqx5WA3EgeedUagtPQ+7pktq2wrX01+3hyaGlUCwkzFkCA==","signedAt":"2026-06-22T12:33:59.494Z","signedBy":"unfragile.ai","version":1},"_links":{"self":"https://unfragile.ai/api/v1/passport/oceanbase--oceanbase","artifact":"https://unfragile.ai/oceanbase--oceanbase","verify":"https://unfragile.ai/api/v1/verify?slug=oceanbase--oceanbase","publicKey":"https://unfragile.ai/api/v1/trust-passport-public-key","spec":"https://unfragile.ai/trust","schema":"https://unfragile.ai/schema.json","docs":"https://unfragile.ai/docs"}}