SSD Nodes Learn Hosting plans →
మార్గదర్శకాలు Matt Connorద్వారా Matt Connor · అప్‌డేట్ చేయబడింది 2026-10-30

సర్వర్‌పై DuckDB vs SQLite: రెండూ ఎందుకు అవసరం

SQLiteలో transactional application state ఉంచి, DuckDBతో Parquet మరియు CSVపై analytics చేయండి. ఒకే VPSలో రెండింటినీ నడిపే కారణం, పనిచేసే ఉదాహరణలు చూడండి.

సర్వర్‌పై DuckDB vs SQLite: ఒక వాక్యంలో సమాధానం

SQLite ఒక OLTP ఇంజిన్ (online transaction processing): ఇది డేటాను వరుసలుగా నిల్వ చేస్తుంది. ఒకేసారి కొన్ని వరుసలను సురక్షితంగా మరియు వేగంగా చదవడానికి, రాయడానికి ఇది రూపొందించబడింది. DuckDB ఒక OLAP ఇంజిన్ (online analytical processing): ఇది డేటాను నిలువు వరుసలుగా నిల్వ చేస్తుంది. లక్షలాది వరుసలను స్కాన్ చేసి, ఒక aggregate ఫలితాన్ని అందించడానికి ఇది రూపొందించబడింది. రెండూ embedded libraries. రెండూ plain file ను తెరుస్తాయి. ఏదానికీ మీరు నిరంతరం పర్యవేక్షించాల్సిన server process అవసరం లేదు.

కాబట్టి “ఏది?” అనే ప్రశ్నకు నిజాయితీగల సమాధానం దాదాపు ఎల్లప్పుడూ “ఒకే VPSలో రెండూ” అనేదే. మీ application తన live state ను SQLiteలో ఉంచుతుంది. మీ reporting, DuckDBతో Parquet మరియు CSV files ను చదువుతుంది. ఇవి ఒకదానితో ఒకటి పోటీ పడవు, ఎందుకంటే ఇవి ఒకే పనిని చేయవు.

రో స్టోరేజ్ మరియు కాలమ్ స్టోరేజ్ సమాధానాన్ని ఎందుకు మారుస్తాయి

SQLite ఒక రో (row)ను పేజీలో ఒకే వరుస క్రమంలో రాస్తుంది. ప్రైమరీ కీ ద్వారా ఒక ఆర్డర్‌ను పొందడానికి ఒక ఇండెక్స్ పేజీ మరియు ఒక డేటా పేజీ అవసరమవుతాయి, అంటే మొత్తం రెండు రీడ్ ఆపరేషన్లు జరుగుతాయి. ఒక అప్లికేషన్ సెకనుకు వేల సార్లు చేసే పని ఇదే: ఒక యూజర్‌ను చదవడం, సెషన్‌ను అప్‌డేట్ చేయడం, ఒక ఆర్డర్‌ను ఇన్సర్ట్ చేయడం.

DuckDB ప్రతి కాలమ్‌ను విడివిడిగా రాసి కంప్రెస్ చేస్తుంది. ఐదు మిలియన్ల రోలలో amount_cents మొత్తాన్ని లెక్కించడానికి amount_cents కాలమ్‌ను మాత్రమే చదువుతుంది, ఫైల్‌లోని మిగిలిన అన్ని బైట్‌లను వదిలేస్తుంది, మరియు విలువల బ్యాచ్‌లపై వెక్టరైజ్డ్ కోడ్ ద్వారా మొత్తాన్ని లెక్కిస్తుంది. ఇతర కాలమ్‌లను డిస్క్ నుండి చదవదు, దీని వల్లే వేగం లభిస్తుంది.

ఇప్పుడు ప్రతి ఇంజిన్‌ను మరొకదాని పనిభారం (workload) కోసం ఉపయోగించి చూడండి. SQLite ఒక కాలమ్ మొత్తాన్ని లెక్కించాలంటే ప్రతి రోను పరిశీలించి, ఒక ఫీల్డ్ కోసం మొత్తం రోను పేజీ నుండి బయటకు తీయాలి, కాబట్టి అది అవసరమైన దానికంటే ఎక్కువ డిస్క్ రీడ్ చేస్తుంది. DuckDB ఒక ఆర్డర్‌ను ఇన్సర్ట్ చేయాలంటే ఒకే విలువ కోసం ప్రతి కాలమ్ స్టోరేజ్‌ను తాకాలి, మరియు అలా చేయడానికి మొత్తం డేటాబేస్ ఫైల్‌పై రైట్ లాక్ (write lock) తీసుకోవాలి. ఏ ఇంజిన్ లోపభూయిష్టమైనది కాదు. ప్రతిదీ అది రూపొందించబడని పనికి సమాధానం ఇస్తోంది.

SQLite ఎక్కడ ఉత్తమమైనది: లావాదేవీల అప్లికేషన్ స్థితి

రైట్‌లు (writes) చిన్నవిగా, తరచుగా జరుగుతూ, మరియు ఏమాత్రం కోల్పోకూడదు అనుకున్నప్పుడు SQLiteని ఎంచుకోండి. సెషన్‌లు, ఆర్డర్‌లు, క్యూ అడ్డు వరుసలు, సెట్టింగ్‌లు, వెబ్ అభ్యర్థన ద్వారా సృష్టించబడే ఏదైనా సరే దీనికి సరిపోతాయి.

sudo apt update && sudo apt install -y sqlite3
sudo install -d -o "$USER" -g "$USER" /srv/app

టేబుల్‌ను సృష్టించి, అదే దశలో రైట్-అహెడ్ లాగింగ్‌ను (write-ahead logging) ఆన్ చేయండి.

sqlite3 /srv/app/app.db <<'SQL'
PRAGMA journal_mode = WAL;
CREATE TABLE IF NOT EXISTS orders (
  id           INTEGER PRIMARY KEY,
  customer     TEXT    NOT NULL,
  placed_at    TEXT    NOT NULL,
  amount_cents INTEGER NOT NULL
);
CREATE INDEX IF NOT EXISTS orders_customer ON orders (customer);
INSERT INTO orders (customer, placed_at, amount_cents)
  VALUES ('ana', '2026-07-30T09:14:00Z', 4200);
SQL

అవుట్‌పుట్‌లోని మొదటి లైన్ wal. ఇది PRAGMA తాను మారిన మోడ్‌ను తెలియజేస్తుంది, మరియు సర్వర్‌లో ఇది అత్యంత ఉపయోగకరమైన సెట్టింగ్. డిఫాల్ట్ రోల్‌బ్యాక్ జర్నల్ మోడ్‌లో, ఒక రైటర్ ప్రతి రీడర్‌ను బ్లాక్ చేస్తుంది. WAL మోడ్‌లో, ఒక రైటర్ డేటాను జోడిస్తున్నప్పుడు కూడా రీడర్‌లు చివరిగా కమిట్ అయిన స్థితిని చదువుతూనే ఉంటారు, కాబట్టి నెమ్మదిగా జరిగే రిపోర్ట్ వెబ్ అభ్యర్థనను ఆపివేయదు.

అడ్డు వరుస (row) వచ్చిందో లేదో తనిఖీ చేయండి:

sqlite3 /srv/app/app.db "SELECT * FROM orders WHERE customer = 'ana';"

మీకు 1|ana|2026-07-30T09:14:00Z|4200 వస్తుంది. డేటాబేస్ పక్కన మరో రెండు ఫైళ్లు app.db-wal మరియు app.db-shm కనిపిస్తాయి, ఇవి రెండూ దానికి చెందినవే. అప్లికేషన్ రన్ అవుతున్నప్పుడు కేవలం app.dbని మాత్రమే కాపీ చేస్తే అది అసంపూర్ణమైన బ్యాకప్‌ను ఇస్తుంది, దీని గురించి కింద మరింత వివరించబడింది.

SQLite ఒక సమయంలో ఒక రైటర్‌ను మాత్రమే అనుమతిస్తుంది. ఆ పరిమితి ఒక లాక్, క్యూ కాదు, కాబట్టి ఎక్కువ సమయం వేచి ఉన్న రెండవ రైటర్ ఎప్పటికీ బ్లాక్ అవ్వకుండా database is lockedతో విఫలమవుతుంది. మీ అప్లికేషన్ తెరిచే ప్రతి కనెక్షన్‌పై PRAGMA busy_timeout = 5000;తో వేచి ఉండే సమయాన్ని పెంచండి. ఐదు సెకన్ల నిరీక్షణ సాధారణ వెబ్ వర్క్‌లోడ్‌లో ఇటువంటి చాలా లోపాలను తొలగిస్తుంది.

మీ వద్ద ఇప్పటికే ఉన్న ఫైళ్లపై analytics: DuckDB ఎక్కడ మెరుగ్గా పనిచేస్తుంది

ప్రశ్న “ఎన్ని”, “ఎంత” లేదా “మొదటి పది ఏవి” అని ప్రారంభమై, input అనేక CSV లేదా Parquet ఫైళ్లుగా ఉన్నప్పుడు DuckDBను ఎంచుకోండి. 27 October 2026 నాటికి version 2.0.0 (LTS release) command line clientను install చేయండి:

curl https://install.duckdb.org | sh

మీరు ఒక versionను నిర్దిష్టంగా ఎంచుకోకపోతే script తాజా stable releaseను install చేస్తుంది. ఉదాహరణకు, మునుపటి releaseలో ఉండటానికి curl https://install.duckdb.org | DUCKDB_VERSION=1.5.6 sh ఉపయోగించవచ్చు. ఇది binaryని ~/.duckdb/cli/latest/duckdb లో install చేసి, దాన్ని మీ PATH లో చేర్చే lineను చూపిస్తుంది. ఇది నడుస్తుందో నిర్ధారించండి:

~/.duckdb/cli/latest/duckdb :memory: "SELECT version();"

Query చేయడానికి ఉపయోగించే వాస్తవిక fileను తయారు చేయండి. ఈ command zstdతో compress చేసిన Parquet fileలో ఐదు million orders rows రాస్తుంది:

mkdir -p /srv/data
duckdb :memory: "
COPY (
  SELECT i                                                     AS id,
         'cust_' || (i % 5000)                                 AS customer,
         TIMESTAMP '2026-01-01 00:00:00' + INTERVAL (i) MINUTE AS placed_at,
         (i * 37) % 20000                                      AS amount_cents
  FROM range(5000000) t(i)
) TO '/srv/data/orders.parquet' (FORMAT parquet, COMPRESSION zstd);"

ఇప్పుడు analytical question అడగండి. Shellను తెరిచి, timerను ప్రారంభించి, import step లేకుండా fileను నేరుగా query చేయండి:

.timer on
SELECT customer,
       count(*)                AS orders,
       sum(amount_cents)/100.0 AS revenue
FROM '/srv/data/orders.parquet'
GROUP BY customer
ORDER BY revenue DESC
LIMIT 5;

ప్రచురించిన సంఖ్యను నమ్మకుండా, మీ స్వంత సంఖ్యను .timer నుంచి చదవండి. ఫలితం మీ disk మరియు core countపై ఆధారపడి ఉంటుంది. ముఖ్యమైనది దాని రూపం. CREATE TABLE లేదు, INSERT లేదు, load step కూడా లేదు: DuckDB Parquet footerను చదివి, queryకు అవసరమైన column chunks ఏవో నిర్ణయించి, అవి మాత్రమే చదివింది. Glob FROM '/srv/data/orders-*.parquet' ఉపయోగిస్తే మొత్తం directory కూడా ఇదే విధంగా పనిచేస్తుంది. ఈ విధంగా ఒక నెలలోని రోజువారీ exports ఒకే queryగా మారతాయి.

వీటన్నింటికీ disk speed ప్రాథమిక పరిమితి. Column scan అనేది దీర్ఘమైన sequential read. అందువల్ల NVMe మరియు పాత SATA storage మధ్య తేడా VPSలో SQLite యొక్క చిన్న random reads కంటే ఇక్కడ స్పష్టంగా కనిపిస్తుంది.

DuckDB నుండి మీ SQLite డేటాబేస్‌ను చదవడం

DuckDB యొక్క sqlite ఎక్స్‌టెన్షన్ ద్వారా ఈ రెండు ఇంజిన్‌లు అనుసంధానించబడతాయి. అప్లికేషన్ డేటాబేస్‌ను 'read only' మోడ్‌లో అటాచ్ చేయండి, తద్వారా అనలిటిక్స్ క్వెరీ లైవ్ స్టేట్‌లోకి ఎటువంటి డేటాను రాయలేదు:

INSTALL sqlite;
LOAD sqlite;
ATTACH '/srv/app/app.db' AS app (TYPE sqlite, READ_ONLY);
SELECT customer, count(*) AS orders
FROM app.orders
GROUP BY customer
ORDER BY orders DESC;

ఇది డేటాను కాపీ చేయకుండా, క్వెరీ సమయంలోనే SQLite ఫైల్ నుండి వరుసలను (rows) చదువుతుంది. ఇది సౌకర్యవంతంగా ఉంటుంది కానీ వేగంగా ఉండదు, ఎందుకంటే డిస్క్‌లోని డేటా ఇంకా రో స్టోరేజ్ (row storage) రూపంలోనే ఉంటుంది మరియు DuckDB దానిని స్కాన్ చేయాల్సి ఉంటుంది. దీనిని ఎగుమతి (export) కోసం మాత్రమే ఉపయోగించండి, ప్రతి ముప్పై సెకన్లకు రీలోడ్ అయ్యే డాష్‌బోర్డ్ కోసం కాదు:

COPY (SELECT * FROM app.orders)
  TO '/srv/data/orders-2026-07.parquet' (FORMAT parquet, COMPRESSION zstd);

ఈ ఒక్క స్టేట్‌మెంట్‌తోనే మొత్తం ప్రక్రియ పూర్తవుతుంది. ఇటీవలి లైవ్ రోస్ (rows) SQLite ఆధీనంలో ఉంటాయి. షెడ్యూల్ చేసిన ఎగుమతి ద్వారా పూర్తయిన కాలపరిమితి డేటాను Parquet ఫార్మాట్‌లోకి మారుస్తుంది. నెలల తరబడి ఉండే డేటాపై వచ్చే ప్రశ్నలకు DuckDB సమాధానమిస్తుంది, అప్లికేషన్ డేటాబేస్ పరిమాణం తక్కువగా ఉంటుంది, దీనివల్ల రైట్ ఆపరేషన్లు వేగంగా జరుగుతాయి.

ఎగుమతిని మాన్యువల్‌గా కాకుండా షెడ్యూల్ ప్రకారం రన్ చేయండి. దీని కోసం systemd service and timer pair సరైన పద్ధతి: ఒకటి COPYని రన్ చేసే యూనిట్, మరొకటి ప్రతి రాత్రి దానిని ట్రిగ్గర్ చేసే టైమర్.

ఒకే VPSలో రెండింటినీ రన్ చేయడం

ఇక్కడ దేనికీ కంటైనర్ అవసరం లేదు, దేనికీ పోర్ట్ అవసరం లేదు. రెండు ఇంజిన్లు లైబ్రరీలు మాత్రమే, కాబట్టి ఇన్‌స్టాలేషన్ అనేది ఒక ప్యాకేజీ మరియు ఫైల్ పాత్ మాత్రమే. మీ స్టాక్‌లోని మిగిలిన భాగాలు ఇప్పటికే ఒకే VPSలో Docker Compose కింద రన్ అవుతుంటే, డేటాబేస్ సర్వీస్‌ను జోడించే బదులు, డేటా డైరెక్టరీని అవసరమైన కంటైనర్‌లోకి మౌంట్ చేయండి, ఎందుకంటే జోడించడానికి అక్కడ ఎటువంటి సర్వీస్ లేదు.

ఈ అమరికలో సమస్యలు రాకుండా ఉండటానికి రెండు నియమాలు ఉన్నాయి.

ప్రతి ఇంజిన్‌కు దాని స్వంత డైరెక్టరీని కేటాయించండి: అప్లికేషన్ వ్రాసే SQLite ఫైల్ కోసం /srv/app, అనలిటిక్స్ చదివే Parquet ఫైళ్ల కోసం /srv/data. అవి ఒకే డైరెక్టరీని పంచుకున్నప్పుడు, ఒకదానిని స్నాప్‌షాట్ చేసే బ్యాకప్ జాబ్ మరొకదానితో పోటీ పడుతుంది.

రెండు ప్రాసెస్‌లను ఒకే DuckDB డేటాబేస్ ఫైల్‌కు రీడ్-రైట్ మోడ్‌లో పాయింట్ చేయవద్దు. కేవలం ఒక ప్రాసెస్ మాత్రమే DuckDB ఫైల్‌ను రైటింగ్ కోసం ఉంచుకోగలదు, రెండవది దానిని ఓపెన్ చేయడంలో విఫలమవుతుంది. ప్రతి ఒక్కటి access_mode = 'READ_ONLY' సెట్ చేసినప్పుడు, అనేక రీడర్లు ఉండటం సమస్య కాదు. SQLite నుండి వచ్చే వారికి ఇది ఆశ్చర్యం కలిగించవచ్చు, అక్కడ సాధారణంగా అనేక ప్రాసెస్‌లు ఒక ఫైల్‌ను పంచుకుంటాయి. మీ అనలిటిక్స్ కేవలం Parquet ఫైళ్లను మాత్రమే చదువుతుంటే, ఈ ప్రశ్న తలెత్తదు, అందుకే డ్యూరబుల్ స్టేట్‌ను SQLiteలో ఉంచడానికి ఇది మరొక కారణం.

బ్యాకప్‌లు భిన్నంగా ఉంటాయి, ఈ వ్యత్యాసం సమస్యలను కలిగిస్తుంది

నడుస్తున్న SQLite డేటాబేస్ మూడు ఫైళ్లను కలిగి ఉంటుంది. cp ఉపయోగించి వాటిని కాపీ చేసేటప్పుడు, రైటింగ్ జరుగుతుంటే, ఆ ఫైల్ ఓపెన్ అవుతుంది కానీ డేటా తప్పుగా ఉంటుంది. అప్లికేషన్ డేటాను రాస్తున్నప్పుడు కూడా స్థిరమైన స్నాప్‌షాట్‌ను తీసుకునే ఇంజిన్ యొక్క సొంత బ్యాకప్ కమాండ్‌ను ఉపయోగించండి:

sqlite3 /srv/app/app.db ".backup '/srv/backup/app-$(date -u +%Y%m%dT%H%M%SZ).db'"
sqlite3 /srv/backup/app-20260730T091400Z.db "PRAGMA integrity_check;"

కాపీ సరిగ్గా జరిగినప్పుడు integrity_check అనేది ok అని ప్రింట్ చేస్తుంది. వేరే ఏదైనా వస్తే, ఆ స్నాప్‌షాట్‌ను తొలగించి మరొకటి తీసుకోండి.

Parquet ఫైళ్లు ఒకసారి రాసిన తర్వాత మారవు, కాబట్టి వాటికి ప్రత్యేక హ్యాండ్లింగ్ అవసరం లేదు: ఆ డైరెక్టరీని బ్యాకప్ చేయండి. మీ VPS నుండి restic బ్యాకప్‌లు ఉపయోగించి రెండు పాత్‌లను సర్వర్ నుండి పంపండి, అప్పుడు మొత్తం డేటా లేయర్ ఒకే బ్యాకప్ జాబ్‌లో రెండు డైరెక్టరీలుగా ఉంటుంది.

విఫలమయ్యే పరిస్థితులు మరియు మీరు ఖచ్చితంగా చూసే strings

SQLite నుంచి వచ్చే database is locked, అది మీ application driver ద్వారా వచ్చినా లేదా sqlite3 shell ద్వారా వచ్చినా, మీ timeout అనుమతించిన సమయంకంటే ఎక్కువసేపు మరొక connection write lockను కలిగి ఉందని అర్థం. ఇది corruption కాదు. ప్రతి connectionపై PRAGMA busy_timeout సెట్ చేయండి. తరువాత అనేక చిన్న transactionsగా ఉండాల్సిన transaction దీర్ఘంగా నడుస్తుందా అని పరిశీలించండి.

Permission change తర్వాత కనిపించే unable to open database file సాధారణంగా processకు fileలో write చేయగలిగినా, దాని directoryలో write చేయలేకపోతున్నదని అర్థం. SQLite database పక్కనే app.db-wal మరియు app.db-shm ను సృష్టిస్తుంది. అందువల్ల .db file మాత్రమే కాదు, ఆ directory కూడా writableగా ఉండాలి.

DuckDB నుంచి వచ్చే IO Error: Could not set lock on file అంటే మరొక process ఇప్పటికే ఆ databaseను writing కోసం open చేసి ఉందని అర్థం. మరో shellను close చేయండి లేదా మీ shellను read onlyగా open చేయండి.

చిన్న VPSలో DuckDB నుంచి వచ్చే Out of Memory Error అంటే queryకు అందుబాటులో ఉన్నదానికంటే ఎక్కువ working memory అవసరమైందని అర్థం. DuckDB intermediate resultsను defaultగా diskపై spill చేస్తుంది. ఇందులో :memory: session కూడా ఉంటుంది. అందువల్ల spilling పనిచేయడానికి database fileను open చేయడం అవసరం కాదు. ఇవి database file పక్కన ఉన్న .tmp directoryలో temporary filesగా రాయబడతాయి. In-memory sessionకు ఇవి మీరు session ప్రారంభించిన ప్రదేశానికి relativeగా ఉన్న .tmp directoryలో రాయబడతాయి. కాబట్టి free disk ఉన్న writable ప్రదేశంలో sessionను ప్రారంభించండి లేదా SET temp_directory = '/var/tmp/duckdb'; తో వేరే ప్రదేశాన్ని నిర్దేశించండి. ముఖ్యమైన setting cap: SET memory_limit = '2GB';. Defaultగా ఇది machine RAMలో 80% ఉంటుంది. కాబట్టి ఇతర services నడుస్తున్న machineలో, ad hoc query మీ applicationను RAM నుంచి బయటకు నెట్టకుండా ఆపేది ఈ limit. string_agg() వంటి కొన్ని aggregates spill చేయలేవు. కొన్ని sorting-based aggregates కూడా spill చేయలేవు. అందువల్ల వాటిపై ఆధారపడిన queryలో memory మళ్లీ పూర్తిగా అయిపోవచ్చు.

Parquetను query చేస్తున్నప్పుడు కనిపించే Binder Error: Referenced column "amount" not found అంటే file schema మీరు గుర్తుంచుకున్న schemaతో సరిపోలడం లేదని దాదాపు ఎల్లప్పుడూ అర్థం. DESCRIBE SELECT * FROM '/srv/data/orders.parquet'; నడిపి, వాస్తవ column namesను తిరిగి చదవండి.

ఆచరణలో ఎలా ఎంచుకోవాలి

రైట్ ప్యాటర్న్ (write pattern) ఏమిటో అడగండి. పవర్ కట్ అయినా డేటా భద్రంగా ఉండాల్సిన అనేక చిన్న రైట్ ఆపరేషన్లు ఉంటే, SQLite వాడండి. రీడ్ ప్యాటర్న్ (read pattern) ఏమిటో అడగండి. సుదీర్ఘ చరిత్రపై అగ్రిగేట్లతో కూడిన పూర్తి స్కాన్‌లు అవసరమైతే, DuckDB వాడండి. చాలా నిజమైన సిస్టమ్‌లు ఈ రెండు ప్రశ్నలకు అవును అని సమాధానం ఇస్తాయి. అప్పుడు సరైన పద్ధతి ఏమిటంటే, ఒక ఇంజిన్‌పై భారం వేయకుండా, ప్రతి ఇంజిన్‌కు దేనిలో అది సమర్థవంతంగా పనిచేస్తుందో ఆ భాగాన్ని కేటాయించడం.

లైవ్ అప్లికేషన్ స్టేట్‌ను DuckDBకి తరలించడం వంటి మైగ్రేషన్‌ను నివారించాలి, ఎందుకంటే ఒక రిపోర్ట్ నెమ్మదిగా ఉందని మీరు భావించవచ్చు. స్టోరేజ్ లేఅవుట్ కారణంగా రిపోర్ట్ నెమ్మదిగా ఉండవచ్చు, కాబట్టి దానికి పరిష్కారం డేటాను ఎగుమతి (export) చేయడం, మీ రైట్ పాత్‌ను తిరిగి రాయడం కాదు.

FAQ

DuckDB నా application database కోసం SQLite స్థానాన్ని భర్తీ చేయగలదా?

తరచుగా write చేసే database కు కాదు. DuckDB మొత్తం database file పై write lock తీసుకుంటుంది, ఒకేసారి ఒక read-write process ను మాత్రమే అనుమతిస్తుంది. ఇది single-row inserts కంటే bulk changes కోసం రూపొందించబడింది. Transactional state ను SQLite లో ఉంచండి. Report అవసరమైనప్పుడు DuckDBతో ATTACH '/srv/app/app.db' AS app (TYPE sqlite, READ_ONLY); ఉపయోగించి దాన్ని చదవండి.

Analytics కోసం DuckDB నిజంగా SQLite కంటే వేగంగా ఉంటుందా?

పెద్ద table పై scans మరియు aggregates కోసం అవును. దీనికి కారణం tuning trick కాదు; storage layout. Queryలో పేర్కొన్న columns ను మాత్రమే DuckDB చదివి, values ను batches గా process చేస్తుంది. ఒక field ను చేరుకోవడానికి SQLite మాత్రం మొత్తం rows ను scan చేయాలి. Primary key ద్వారా ఒకే row ను తీసుకునే సందర్భంలో ఫలితం మారుతుంది. SQLite రెండు pages ను మాత్రమే access చేస్తుంది. DuckDB ప్రతి column యొక్క storage ను access చేస్తుంది.

VPS పై DuckDB నడపడానికి నాకు ఎక్కువ RAM అవసరమా?

అవసరం లేదు. అయితే దానికి ఒక limit మరియు spill చేయడానికి తగిన స్థలం ఇవ్వండి. :memory: session లో కూడా DuckDB intermediate results ను default గా disk కు spill చేస్తుంది. దీనికి temporary directory writable గా ఉండాలి మరియు అందులో free space ఉండాలి. తరువాత SET memory_limit = '2GB'; ను మీ VPS భరించగల విలువకు set చేయండి. దీన్ని default అయిన RAMలో 80% వద్ద వదిలేస్తే, ఒక పెద్ద GROUP BY Out of Memory Error ను పెంచవచ్చు లేదా ఇతర services ను RAM నుంచి బయటకు నెట్టవచ్చు.

నా SQLite data ను Parquet లోకి ఎలా తీసుకెళ్లాలి?

DuckDB నుంచి SQLite file ను attach చేసి, COPY (SELECT * FROM app.orders) TO '/srv/data/orders.parquet' (FORMAT parquet, COMPRESSION zstd); తో query ఫలితాన్ని నేరుగా copy చేయండి. గత నెల rows వంటి closed periods కోసం దీన్ని schedule ప్రకారం run చేయండి. Application ఇంకా write చేస్తున్న recent rows ను SQLite లోనే ఉంచండి.

వీటిలో దేనిని backup చేయాలి? ఎలా చేయాలి?

రెండింటినీ, కానీ వేర్వేరు పద్ధతుల్లో. cp కు బదులుగా sqlite3 app.db ".backup '/srv/backup/app.db'" ఉపయోగించి SQLite snapshots తీసుకోండి. Running database ఒక -wal మరియు -shm file కూడా కావడంతో, plain copy మధ్యలో విడిపోయిన అసంపూర్ణ copy కావచ్చు. Parquet files ఒకసారి రాసిన తరువాత ఎప్పటికీ మారవు. అందువల్ల directory ను copy చేయడం సరిపోతుంది.

ఈ వ్యాసం ఉపయోగకరంగా ఉందా?