My Editor Job Has Been Replaced by AI — A seekdb Fork Table Capability Test Report

Posted on In Views: Word count in article: 2.1k Reading time ≈ 8 mins.
An experiment report on having an AI Agent automatically deploy seekdb and test its Fork Table capability. Through five scenarios, data isolation, version rollback, a synthetic-data sandbox, and multi-branch A/B experiments, it demonstrates the value Fork Table brings to AI developers as lightweight data-branch management.

If you still won’t step in and embrace AI right now, then every single day you’re falling further behind an entire era.

🌟 Tip: The seekdb used in this article is the AI-native database open-sourced by OceanBase. You’re welcome to try it at https://github.com/oceanbase/seekdb, it should bring a simpler, more efficient data-management solution to your AI application development!

Background

This morning, while studying technical-support colleague Imagawa’s article How to Observe Locks in OceanBase?, I suddenly had an idea: I could let an Agent deploy seekdb for me, test a new feature I’m interested in, and then write it up as an article.

So let’s just have the Agent test seekdb’s fork table capability for me, and see what important uses this fork table feature has for developers in the AI era.

My Editor Job Has Been Replaced by AI — A seekdb Fork Table Capability Test Report

Installing seekdb by hand can run into problems, such as a dependency library being the wrong version. But when the agent installs it, it automatically analyzes the error logs, resolves the problems it encounters, and ultimately completes the deployment.

My Editor Job Has Been Replaced by AI — A seekdb Fork Table Capability Test Report

You can find the DDL execution records from its test in seekdb, so the agent really did run the tests.

My Editor Job Has Been Replaced by AI — A seekdb Fork Table Capability Test Report

Before the main text begins, let me “manually” say a few words about what fork table does, using a Vibe Coding platform as an example:

My Editor Job Has Been Replaced by AI — A seekdb Fork Table Capability Test Report

Xiao Li is using AI to generate a figurine store. He tells the AI, “add a limited-edition tag field to the products table,” and the AI automatically generates an ALTER TABLE statement and executes it. At this point the platform automatically creates a Table Fork, equivalent to taking a snapshot of the current table structure.

A while later, through Vibe Coding, Xiao Li has the AI change a few fields and add price-discount logic. But on testing, he finds the discount calculation has a BUG, and the order flow that used to work now all breaks.

This is where Table Fork’s rollback capability comes in handy.

On the platform, Xiao Li sees a version history list showing:

  • “Version 1: initial e-commerce template”
  • “Version 2: added the limited-edition field”
  • “Version 3: added discount logic”

He directly clicks to roll back to Version 2, and the entire table structure and data instantly revert to the state before discounts were added, and the order flow runs again.

This capability is crucial for the Vibe Coding scenario, because AI-generated code isn’t always correct, and users need to experiment boldly and fail fast. With Table Fork, every change has an undo button, so users dare to let the AI modify the database with confidence, and if it breaks, roll back with one click, with no worry about messing up the data. It’s like Git’s version management for code, except Table Fork is version management for database tables.

Moreover, in every AI-Native Database, Table Fork is usually just a single DDL operation that executes very fast, completing the Fork action at the millisecond level. Compared with database version-control tools like Flyway, the capability it provides is more flexible and powerful.

From here on, everything is the report automatically tested and output by the AI Agent. After a human review, no obvious problems were found, so there was no human intervention.

seekdb Fork Table Capability Test Report: An Essential Feature for AI Developers

Test date: March 31, 2026
Test environment: seekdb 1.1.0.0 on macOS (Apple Silicon)
Test databases: my_test, fork_test

1. Overview of Fork Table’s Core Features

Fork Table is a table-level capability provided by seekdb that can create a copy of a target table based on a source table, at a consistent-snapshot moment automatically chosen by the system.

My Editor Job Has Been Replaced by AI — A seekdb Fork Table Capability Test Report

Its core features include:

Feature Description
Isolation The target table and source table are isolated from each other and can be used as an independent table object for subsequent reads and writes
Consistency The target table reflects a consistent snapshot of the source table at Fork time; subsequent changes to the source table don’t affect the target table
Efficiency Reuses existing data organization and storage structures as much as possible, reducing copy overhead and making data-branch creation more lightweight
Progressive availability The target table can provide access before the Fork fully completes; the background process doesn’t change the externally visible consistency semantics

Basic Syntax

1
FORK TABLE <source_table_name> TO <target_table_name>;

2. Basic Functionality Tests

2.1 Test: Data Isolation Verification

My Editor Job Has Been Replaced by AI — A seekdb Fork Table Capability Test Report

Test steps:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
-- 1. Create the source table and write data
CREATE TABLE t1 (c1 INT PRIMARY KEY, c2 INT);
INSERT INTO t1 VALUES(1, 10), (2, 20), (3, 30);

-- 2. Fork to create a copy
FORK TABLE t1 TO t1_fork;

-- 3. Modify the source table
INSERT INTO t1 VALUES (4, 40);
UPDATE t1 SET c2 = 999 WHERE c1 = 1;

-- 4. Modify the fork table
INSERT INTO t1_fork VALUES (5, 500);
UPDATE t1_fork SET c2 = 888 WHERE c1 = 2;

Test results:

Table Data Rows Verification Result
t1 (source) (1,999), (2,20), (3,30), (4,40) ✅ Source-table changes don’t affect the fork table
t1_fork (1,10), (2,888), (3,30), (5,500) ✅ Fork-table changes don’t affect the source table

Conclusion: Fork Table achieves fully isolated writes; modifications to the source and target tables don’t affect each other.

3. Tests for AI-Developer Use Cases

3.1 Scenario 1: A/B Experiments — Prompt Strategy Testing

My Editor Job Has Been Replaced by AI — A seekdb Fork Table Capability Test Report

Scenario: Based on the production knowledge-base data, create an experiment branch to test different Prompt-generation strategies without affecting the live service.

Test steps:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
-- Assume doc_table is the production knowledge base
SELECT * FROM doc_table LIMIT 3;
-- Output:
-- | 1 | hello world | seekdb Elasticsearch database |
-- | 2 | hello world, what is your name | seekdb database |
-- | 3 | hello world, how are you | seekdb mysql database |

-- Fork out an experiment branch
FORK TABLE doc_table TO doc_table_experiment_v1;

-- Add test data generated by the new Prompt in the experiment branch
INSERT INTO doc_table_experiment_v1 VALUES
(7, '[1,4,1]', 'hello oceanbase, tell me about seekdb',
     'seekdb is an AI-native search database with hybrid search capabilities'),
(8, '[2,2,2]', 'how to use fork table in seekdb',
     'fork table allows you to create isolated snapshots for experimentation');

Test results:

Branch Row Count Purpose
doc_table (production) 6 rows Keeps production data unchanged
doc_table_experiment_v1 8 rows Contains the newly added experiment data

Hybrid search verification:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
SET @parm = '{
    "query": {
        "query_string": {
            "fields": ["query", "content"],
            "query": "seekdb fork"
        }
    },
    "knn" : {
        "field": "vector",
        "k": 5,
        "query_vector": [1,2,3]
    }
}';

SELECT json_pretty(DBMS_HYBRID_SEARCH.SEARCH('doc_table_experiment_v1', @parm));

Search results (Top 3):

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
[
  {
    "c1": 8,
    "query": "how to use fork table in seekdb",
    "_score": 3.81,
    "vector": "[2,2,2]",
    "content": "fork table allows you to create isolated snapshots for experimentation"
  },
  {
    "c1": 1,
    "query": "hello world",
    "_score": 1.35,
    "vector": "[1,2,3]",
    "content": "seekdb Elasticsearch database"
  },
  {
    "c1": 7,
    "query": "hello oceanbase, tell me about seekdb",
    "_score": 1.27,
    "vector": "[1,4,1]",
    "content": "seekdb is an AI-native search database with hybrid search capabilities"
  }
]

Conclusion: ✅ The experiment branch supports full hybrid search, allowing safe testing of new Prompt strategies.

3.2 Scenario 2: Data Version Management and Rollback

My Editor Job Has Been Replaced by AI — A seekdb Fork Table Capability Test Report

Scenario: Create version snapshots for production data, supporting fast rollback and version comparison after data revisions.

Test steps:

1
2
3
4
5
6
-- Create a version snapshot
FORK TABLE doc_table TO doc_table_v1_backup;

-- Simulate updates/deletes on production data
DELETE FROM doc_table WHERE c1 = 1;
UPDATE doc_table SET content = 'updated content' WHERE c1 = 2;

Test results:

Version Data for c1=1 Data for c1=2 Status
doc_table_v1_backup hello world seekdb database ✅ Unchanged
doc_table (current) Deleted updated content Changed

Conclusion: ✅ Fork Table enables data version snapshots, supporting fast rollback to any historical version.

3.3 Scenario 3: Vibe Coding — Synthetic-Data Iteration

My Editor Job Has Been Replaced by AI — A seekdb Fork Table Capability Test Report

Scenario: Generate synthetic data in a forked copy for AI model training or testing, quickly building and validating synthetic datasets.

Test steps:

1
2
3
4
5
6
7
8
9
10
11
-- Create a synthetic-data experiment branch
FORK TABLE doc_table TO doc_table_synthetic_v1;

-- AI-generated synthetic data
INSERT INTO doc_table_synthetic_v1 VALUES
(100, '[0.5,0.5,0.5]', 'AI generated query about databases',
     'synthetic data for training ML models'),
(101, '[0.6,0.6,0.6]', 'machine learning search optimization',
     'AI generated content for testing'),
(102, '[0.7,0.7,0.7]', 'neural network vector similarity',
     'synthetic embedding data');

Test results:

1
2
3
4
5
6
Synthetic-data branch data:
| c1  | query                                | content                               |
|-----|--------------------------------------|---------------------------------------|
| 100 | AI generated query about databases   | synthetic data for training ML models |
| 101 | machine learning search optimization | AI generated content for testing      |
| 102 | neural network vector similarity     | synthetic embedding data              |

Conclusion: ✅ You can quickly iterate on AI-generated data in an isolated synthetic-data branch without affecting production data.

3.4 Scenario 4: Sandbox Validation — Index-Strategy Testing

My Editor Job Has Been Replaced by AI — A seekdb Fork Table Capability Test Report

Scenario: Create a sandbox environment based on a production-data snapshot to safely test new index strategies or table-structure changes.

Test steps:

1
2
3
4
5
6
7
8
-- Fork a table for sandbox testing
FORK TABLE doc_table TO doc_table_sandbox;

-- Test dropping/rebuilding indexes in the sandbox
ALTER TABLE doc_table_sandbox DROP INDEX idx2;

-- Verify the production table is unaffected
SHOW INDEX FROM doc_table WHERE Key_name = 'idx2';

Test results:

Table idx2 Index Status Description
doc_table_sandbox Dropped Can run new index tests
doc_table (production) Exists Index unaffected

Conclusion: ✅ The sandbox table supports DDL operations, allowing safe testing of index-strategy changes.

3.5 Scenario 5: Multi-Branch Comparison Experiments

My Editor Job Has Been Replaced by AI — A seekdb Fork Table Capability Test Report

Scenario: Derive multiple branch versions from the same baseline data, run different data-strategy experiments on each, compare the results, and choose the best scheme.

Test steps:

1
2
3
4
5
6
7
8
9
10
11
12
13
-- Create multiple strategy branches
FORK TABLE doc_table TO doc_table_strategy_a;
FORK TABLE doc_table TO doc_table_strategy_b;

-- Strategy A: tech-oriented data
INSERT INTO doc_table_strategy_a VALUES
(201, '[0.9,0.8,0.7]', 'database optimization techniques',
     'index tuning and query optimization for better performance');

-- Strategy B: business-oriented data
INSERT INTO doc_table_strategy_b VALUES
(301, '[0.8,0.9,0.6]', 'business intelligence analytics',
     'data driven decision making for enterprise');

Vector-search comparison results:

Branch Search query_vector Top Result _score
strategy_a [0.9,0.8,0.7] database optimization techniques 1.0
strategy_b [0.8,0.9,0.6] business intelligence analytics 1.0

Conclusion: ✅ Multiple branches can experiment with different data strategies in parallel, supporting A/B testing and effectiveness comparison.

4. Core Capabilities Summary

My Editor Job Has Been Replaced by AI — A seekdb Fork Table Capability Test Report

4.1 Capability Matrix

Capability Support AI-Developer Value
Data isolation ✅ Fully isolated Safe experiments without affecting production
Consistent snapshot ✅ Point-in-time consistent Reproducible experiment environments
Lightweight creation ✅ Reuses storage Quickly create multiple experiment branches
Vector index inheritance ✅ Fully inherited Hybrid search available immediately
Full-text index inheritance ✅ Fully inherited Text search available immediately
DDL operation support ✅ Independent modification Can test table-structure changes
Multi-branch parallelism ✅ Unlimited Supports multi-strategy comparison experiments

Use 1: RAG System Prompt Engineering

1
2
3
4
5
6
-- Create a branch for each Prompt version
FORK TABLE knowledge_base TO kb_prompt_v1;
FORK TABLE knowledge_base TO kb_prompt_v2;
FORK TABLE knowledge_base TO kb_prompt_v3;

-- Test the embedding and retrieval effectiveness of different Prompts in each branch

Use 2: Data Version Control for Model Iteration

1
2
3
4
5
-- Create a data snapshot for each model-training batch
FORK TABLE training_data TO train_data_model_v1;
FORK TABLE training_data TO train_data_model_v2;

-- Supports model-effectiveness comparison and issue traceback

Use 3: A Sandbox for Synthetic-Data Generation

1
2
3
4
5
-- Create a synthetic-data playground
FORK TABLE production_data TO synthetic_data_gen;

-- Generate and validate AI synthetic data in the sandbox
INSERT INTO synthetic_data_gen SELECT ...; -- AI-generated data

Use 4: Feature-Engineering Experiments

1
2
3
4
5
-- Create a branch for each feature combination
FORK TABLE features TO features_experiment_alpha;
FORK TABLE features TO features_experiment_beta;

-- Test the impact of different features on model effectiveness

5. Test Environment Information

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# seekdb status
seekdb-status
# Output: seekdb is running (PID: 54636)

# Connection info
mysql -h127.0.0.1 -uroot -P2881 -A

# Web admin interface
http://127.0.0.1:2886/

# Data directory
/opt/homebrew/var/seekdb/data

# Log file
/opt/homebrew/var/seekdb/data/log/seekdb.log

6. Summary

seekdb’s Fork Table capability provides AI developers with a lightweight, isolated, reproducible data-experimentation environment, especially well suited to the following scenarios:

  1. RAG system development: safely test different Prompt strategies and embedding models
  2. Data version management: create rollback-able snapshots for training data and knowledge bases
  3. Synthetic-data iteration: generate and validate AI synthetic data in an isolated environment
  4. A/B experiments: compare multiple data strategies and index schemes in parallel
  5. Sandbox validation: safely test table-structure changes and index optimizations

Fork Table combines perfectly with seekdb’s vector-search and full-text-search capabilities, letting AI developers quickly build and iterate search-augmented applications.

Test report generated at: March 31, 2026

Manual Opening, Manual Closing

My Editor Job Has Been Replaced by AI — A seekdb Fork Table Capability Test Report