SawitDB

https://github.com/wowoengine/sawitdb
Admin
SawitDB is a unique database solution using binary .sawit files with a paged heap file architecture,...
Tokens:11,726
Snippets:65
Trust Score:4.4
License:MIT
Update:9 months ago
Show doc for...
Tokens:
Raw
### SawitDB Installation and Setup (Bash)

Source: https://github.com/wowoengine/sawitdb/blob/main/docs/index.html

Provides commands for cloning the SawitDB repository, installing Node.js dependencies, and preparing the project for initialization.

```bash
git clone https://github.com/WowoEngine/SawitDB.git
cd SawitDB
npm install # Pure Node.js, no heavy deps!
```

--------------------------------

### SawitDB Server Start Script

Source: https://github.com/wowoengine/sawitdb/blob/main/docs/index.html

Provides the command to start the SawitDB server, specifying the port. It also shows environment variables that can be used to configure the server's host, data directory, and authentication.

```bash
node bin/sawit-server.js --port 7878
```

```environment
SAWIT_PORT=7878
SAWIT_HOST=0.0.0.0
SAWIT_DATA_DIR=./data
SAWIT_AUTH=user:pass
```

--------------------------------

### Start SawitDB Server

Source: https://github.com/wowoengine/sawitdb/blob/main/README.md

Executes the SawitDB server using Node.js. The server defaults to listening on 0.0.0.0:7878, enabling network connections.

```bash
node src/SawitServer.js
```

--------------------------------

### Deploy SawitDB Server with Configuration

Source: https://context7.com/wowoengine/sawitdb/llms.txt

Starts a SawitDB server, enabling network access with authentication and configuration options. It uses the `SawitServer` class and allows setting port, host, data directory, authentication credentials, and connection limits. The server supports graceful shutdown via SIGINT.

```javascript
const SawitServer = require('./src/SawitServer');
const path = require('path');

// Configure server
const server = new SawitServer({
    port: 7878,
    host: '0.0.0.0',
    dataDir: path.join(__dirname, 'data'),
    auth: {
        'admin': 'secretpass123',
        'reader': 'readonly456'
    },
    maxConnections: 100,
    queryTimeout: 30000,
    logLevel: 'info' // 'debug', 'info', 'warn', 'error'
});

// Start server
server.start();
console.log('SawitDB server running on port 7878');

// Graceful shutdown
process.on('SIGINT', () => {
    console.log('Shutting down...');
    server.stop();
    process.exit(0);
});

// Environment variable configuration
// SAWIT_PORT=8080 SAWIT_HOST=127.0.0.1 SAWIT_DATA_DIR=/var/db node server.js
```

--------------------------------

### SawitDB AQL Data Manipulation Examples (JavaScript)

Source: https://github.com/wowoengine/sawitdb/blob/main/docs/index.html

Demonstrates common database operations using SawitDB's Agricultural Query Language (AQL), including creating tables, inserting, selecting, updating, and deleting data.

```javascript
// Create Land
LAHAN sawit_blok_a

// Plant Seeds (Insert)
TANAM KE sawit (id, bibit, umur) BIBIT (1, 'Tenera', 5)

// Harvest (Select)
PANEN * DARI sawit DIMANA umur > 3

// Fertilize (Update)
PUPUK sawit DENGAN status='Panen' DIMANA umur >= 10

// Evict (Delete)
GUSUR DARI sawit DIMANA id = 99
```

--------------------------------

### Connect to SawitDB with Connection String Authentication (JavaScript)

Source: https://context7.com/wowoengine/sawitdb/llms.txt

This example demonstrates how to establish connections to a SawitDB server using connection strings that include authentication credentials. It covers basic connections, username/password authentication, handling special characters in passwords via URL encoding, and connecting to different hosts and ports. Error handling for authentication failures is also included. Dependencies include the './src/SawitClient' module.

```javascript
const SawitClient = require('./src/SawitClient');

async function authenticatedConnection() {
    // Basic connection (no auth)
    const client1 = new SawitClient('sawitdb://localhost:7878/mydb');

    // With authentication
    const client2 = new SawitClient('sawitdb://username:password@localhost:7878/mydb');

    // With special characters in password (URL encoded)
    const client3 = new SawitClient('sawitdb://admin:p%40ssw0rd%21@localhost:7878/production');

    // Connect to different host and port
    const client4 = new SawitClient('sawitdb://user:pass@192.168.1.100:8080/remote_db');

    try {
        await client2.connect();
        console.log('Authenticated successfully');

        // Perform operations
        await client2.query('LAHAN secure_data');

    } catch (error) {
        if (error.message.includes('Invalid credentials')) {
            console.error('Authentication failed: Wrong username or password');
        } else if (error.message.includes('Authentication required')) {
            console.error('Server requires authentication');
        } else {
            console.error('Connection error:', error.message);
        }
    } finally {
        client2.disconnect();
    }
}

authenticatedConnection();

```

--------------------------------

### Pagination and Filtering Syntax (SQL)

Source: https://github.com/wowoengine/sawitdb/blob/main/README.md

Provides examples of advanced data retrieval techniques, including pagination using LIMIT and OFFSET, and complex filtering conditions with BETWEEN and IS NOT NULL.

```sql
SELECT * FROM users ORDER BY age DESC LIMIT 5 OFFSET 10
SELECT * FROM users WHERE age BETWEEN 18 AND 30 AND status IS NOT NULL
```

--------------------------------

### Insert Data Syntax (SQL)

Source: https://github.com/wowoengine/sawitdb/blob/main/README.md

Shows the syntax for inserting new data records into a table, with examples in both 'Tani' (AQL) and Generic SQL. The 'Tani' edition supports auto-generating IDs if not provided.

```sql
-- Tani
TANAM KE users (name, role) BIBIT ('Alice', 'Admin')
-- Generic
INSERT INTO users (name, role) VALUES ('Alice', 'Admin')
```

--------------------------------

### Clone SawitDB Repository

Source: https://github.com/wowoengine/sawitdb/blob/main/README.md

This command clones the SawitDB project from GitHub. Ensure you have Git installed and configured on your system before executing.

```bash
git clone https://github.com/WowoEngine/SawitDB.git
```

--------------------------------

### Aggregation and Grouping Syntax (SQL)

Source: https://github.com/wowoengine/sawitdb/blob/main/README.md

Provides examples for performing aggregate functions like COUNT and AVG, and grouping results by a specified field. Supports 'Tani' (AQL) and is coming soon for Generic SQL.

```sql
HITUNG COUNT(*) DARI [table]
HITUNG AVG(price) DARI [products] KELOMPOK [category]
-- Generic Keyword Alias
SELECT AVG(price) FROM [products] GROUP BY [category] (Coming Soon)
```

--------------------------------

### Local SawitDB Connection and Operations in JavaScript

Source: https://context7.com/wowoengine/sawitdb/llms.txt

Demonstrates how to initialize a local SawitDB instance, create tables, insert, select, update, and delete data using both Agricultural Query Language (AQL) and generic SQL syntax. It requires the './src/WowoEngine' module.

```javascript
const SawitDB = require('./src/WowoEngine');
const path = require('path');

// Create or open database
const dbPath = path.join(__dirname, 'mydata.sawit');
const db = new SawitDB(dbPath);

// Create table (Agricultural syntax)
console.log(db.query("LAHAN products"));
// Output: "Kebun 'products' telah dibuka."

// Create table (Generic SQL syntax)
console.log(db.query("CREATE TABLE users"));

// Insert data with Agricultural syntax
db.query("TANAM KE products (id, name, price, stock) BIBIT (1, 'Laptop', 1200, 50)");
db.query("TANAM KE products (id, name, price, stock) BIBIT (2, 'Mouse', 25, 200)");
db.query("TANAM KE products (id, name, price, stock) BIBIT (3, 'Keyboard', 75, 150)");

// Insert with Generic syntax
db.query("INSERT INTO users (name, role) VALUES ('Alice', 'Admin')");

// Select all records
const allProducts = db.query("PANEN * DARI products");
console.log(allProducts);
// Output: [{id: 1, name: 'Laptop', price: 1200, stock: 50}, ...]

// Select with WHERE clause
const expensiveItems = db.query("PANEN * DARI products DIMANA price > 50");
console.log(expensiveItems);
// Output: [{id: 1, name: 'Laptop', price: 1200, stock: 50}, {id: 3, name: 'Keyboard', price: 75, stock: 150}]

// Update records
db.query("PUPUK products DENGAN stock=45 DIMANA id = 1");
// Generic: UPDATE products SET stock=45 WHERE id = 1

// Delete records
db.query("GUSUR DARI products DIMANA stock < 100");
// Generic: DELETE FROM products WHERE stock < 100

// Show all tables
console.log(db.query("LIHAT LAHAN"));
// Generic: SHOW TABLES
// Output: ['products', 'users']
```

--------------------------------

### Multi-Database Management with SawitClient

Source: https://context7.com/wowoengine/sawitdb/llms.txt

Illustrates how to manage multiple databases using the SawitClient. This includes creating, listing, switching between, and dropping databases. It showcases both the agricultural syntax (e.g., BUKA WILAYAH) and generic SQL-like syntax (e.g., CREATE DATABASE). Requires an active SawitClient connection.

```javascript
const SawitClient = require('./src/SawitClient');

async function multiDatabaseExample() {
    const client = new SawitClient('sawitdb://localhost:7878');
    await client.connect();

    // Create new database (Agricultural syntax)
    await client.query('BUKA WILAYAH sales_db');
    // Generic syntax: CREATE DATABASE sales_db

    await client.query('BUKA WILAYAH inventory_db');
    await client.query('BUKA WILAYAH analytics_db');

    // List all databases
    const databases = await client.listDatabases();
    console.log('Databases:', databases);
    // Output: ['sales_db', 'inventory_db', 'analytics_db', ...]

    // Show databases with query (Agricultural)
    const dbList = await client.query('LIHAT WILAYAH');
    console.log(dbList);
    // Generic: SHOW DATABASES

    // Switch to specific database (Agricultural)
    await client.query('MASUK WILAYAH sales_db');
    // Generic: USE sales_db

    // Or use client method
    await client.use('inventory_db');
    console.log('Now using inventory_db');

    // Work with current database
    await client.query('LAHAN products');
    await client.query("TANAM KE products (sku, name) BIBIT ('A001', 'Widget')");

    // Switch to another database
    await client.use('analytics_db');
    await client.query('LAHAN reports');

    // Drop database (Agricultural)
    await client.query('BAKAR WILAYAH old_database');
    // Generic: DROP DATABASE old_database
    // Note: This is IRREVERSIBLE!

    // Or use client method
    await client.dropDatabase('temp_db');

    client.disconnect();
}

multiDatabaseExample();
```

--------------------------------

### SawitDB AQL vs. Generic SQL Syntax

Source: https://github.com/wowoengine/sawitdb/blob/main/README.md

Demonstrates the dual syntax support in SawitDB 2.3, showcasing equivalent operations in both the Agricultural Query Language (AQL) and standard SQL.

```markdown
| Operation | Agricultural Query Language (AQL) | Generic SQL (Standard) |
| :--- | :-------------------------------- | :--------------------- |
| **Create DB** | `BUKA WILAYAH sales_db` | `CREATE DATABASE sales_db` |
| **Use DB** | `MASUK WILAYAH sales_db` | `USE sales_db` |
| **Show DBs** | `LIHAT WILAYAH` | `SHOW DATABASES` |
| **Drop DB** | `BAKAR WILAYAH sales_db` | `DROP DATABASE sales_db` |
| **Create Table** | `LAHAN products` | `CREATE TABLE products` |
| **Insert** | `TANAM KE products (...) BIBIT (...)` | `INSERT INTO products (...) VALUES (...)` |
| **Select** | `PANEN * DARI products DIMANA ...` | `SELECT * FROM products WHERE ...` |
| **Update** | `PUPUK products DENGAN ...` | `UPDATE products SET ...` |
| **Delete** | `GUSUR DARI products DIMANA ...` | `DELETE FROM products WHERE ...` |
| **Indexing** | `INDEKS products PADA price` | `CREATE INDEX ON products (price)` |
| **Aggregation** | `HITUNG SUM(stock) DARI products` | *Same Syntax*
```

--------------------------------

### Create Table Syntax (SQL)

Source: https://github.com/wowoengine/sawitdb/blob/main/README.md

Demonstrates the syntax for creating a new table in the database using both 'Tani' (AQL) and Generic SQL commands. No specific schema definition is required for 'Tani' edition.

```sql
-- Tani
LAHAN users
-- Generic
CREATE TABLE users
```

--------------------------------

### Show Tables Syntax (SQL)

Source: https://github.com/wowoengine/sawitdb/blob/main/README.md

Provides the commands to list all tables within the current database, supporting both 'Tani' (AQL) and Generic SQL syntaxes.

```sql
-- Tani
LIHAT LAHAN
-- Generic
SHOW TABLES
```

--------------------------------

### SawitDB CLI Tools

Source: https://github.com/wowoengine/sawitdb/blob/main/docs/index.html

Illustrates how to use SawitDB's command-line interface (CLI) for managing the database. It distinguishes between local and network CLI usage and suggests using '.help' for command guidance.

```bash
node cli/local.js
node cli/remote.js [url]
```

--------------------------------

### Initialize SawitDB Engine (JavaScript)

Source: https://github.com/wowoengine/sawitdb/blob/main/docs/index.html

Initializes the SawitDB engine, creating the database file if it doesn't exist. Requires the path to the .sawit file.

```javascript
const SawitDB = require('./src/WowoEngine');
const path = require('path');

// Initialize the engine. File created automatically.
const db = new SawitDB(path.join(__dirname, 'plantation.sawit'));
```

--------------------------------

### Dual Syntax Operations in SawitDB (JavaScript)

Source: https://context7.com/wowoengine/sawitdb/llms.txt

Demonstrates how to perform various database operations using both Agricultural Query Language (AQL) and standard SQL-like syntax within SawitDB. This snippet showcases database creation, table management, data manipulation (insert, select, update, delete), and indexing, highlighting the interchangeable nature of the two syntaxes.

```javascript
const db = new SawitDB('./dual_syntax.sawit');

// Database operations - Both syntaxes work identically
db.query("BUKA WILAYAH mydb");          // Agricultural
db.query("CREATE DATABASE mydb");        // Generic SQL

db.query("LIHAT WILAYAH");              // Agricultural
db.query("SHOW DATABASES");             // Generic SQL

// Table operations
db.query("LAHAN customers");            // Agricultural
db.query("CREATE TABLE customers");     // Generic SQL

db.query("LIHAT LAHAN");                // Agricultural
db.query("SHOW TABLES");                // Generic SQL

db.query("BAKAR LAHAN old_table");      // Agricultural
db.query("DROP TABLE old_table");       // Generic SQL

// Data manipulation
db.query("TANAM KE customers (name, email) BIBIT ('John', 'john@example.com')");  // Agricultural
db.query("INSERT INTO customers (name, email) VALUES ('Jane', 'jane@example.com')"); // Generic

db.query("PANEN * DARI customers");     // Agricultural
db.query("SELECT * FROM customers");    // Generic

db.query("PUPUK customers DENGAN email='newemail@example.com' DIMANA name='John'"); // Agricultural
db.query("UPDATE customers SET email='newemail@example.com' WHERE name='John'");    // Generic

db.query("GUSUR DARI customers DIMANA name='John'");  // Agricultural
db.query("DELETE FROM customers WHERE name='John'");   // Generic

// Advanced features
db.query("INDEKS customers PADA email");           // Agricultural
db.query("CREATE INDEX ON customers (email)");     // Generic

// Note: Some operators like WHERE, ORDER BY, LIMIT, OFFSET work the same in both
const results = db.query("SELECT name FROM customers WHERE email LIKE '%@example.com' ORDER BY name ASC LIMIT 10");

```

--------------------------------

### Database Management Syntax (SQL)

Source: https://github.com/wowoengine/sawitdb/blob/main/README.md

Covers commands for managing databases, including creation, switching context, listing, and deletion. Both 'Tani' (AQL) and Generic SQL syntaxes are supported.

```sql
-- Tani Edition (AQL)
BUKA WILAYAH [db]      -- CREATE DATABASE [db]
MASUK WILAYAH [db]      -- USE [db]
LIHAT WILAYAH          -- SHOW DATABASES
BAKAR WILAYAH [db]      -- DROP DATABASE [db]

-- Generic SQL (Standard)
CREATE DATABASE [db]
USE [db]
SHOW DATABASES
DROP DATABASE [db]
```

--------------------------------

### Indexing Syntax (SQL)

Source: https://github.com/wowoengine/sawitdb/blob/main/README.md

Demonstrates the syntax for creating indexes on table fields to improve query performance. Supports both a concise 'Tani' (AQL) format and standard SQL.

```sql
INDEKS [table] PADA [field]
-- or
CREATE INDEX ON [table] ([field])
```

--------------------------------

### SawitDB Tani Edition vs Generic SQL

Source: https://github.com/wowoengine/sawitdb/blob/main/docs/index.html

Compares SawitDB's Tani Edition syntax with Generic SQL for common database operations like creating databases, showing tables, aggregation, and indexing. Tani Edition uses specific keywords like BUKA WILAYAH, LIHAT LAHAN, and HITUNG.

```AQL
BUKA WILAYAH [db]
LIHAT LAHAN
HITUNG SUM(x) DARI [t]
INDEKS [t] PADA [f]
```

```SQL
CREATE DATABASE [db]
SHOW TABLES
SELECT SUM(x) FROM [t]
CREATE INDEX ON [t] ([f])
```

--------------------------------

### SawitClient API Connection and Query

Source: https://github.com/wowoengine/sawitdb/blob/main/docs/index.html

Demonstrates how to connect to a SawitDB instance using the SawitClient, execute a query, and disconnect. It utilizes the 'sawitdb://' protocol for remote data management.

```javascript
const SawitClient = require('./src/SawitClient');

// Connect
const client = new SawitClient(
'sawitdb://localhost:7878/plantation'
);
await client.connect();

// Query
const result = await client.query(
'PANEN * DARI sawit'
);

// Disconnect
client.disconnect();
```

--------------------------------

### Execute Parameterized Queries with SawitDB (JavaScript)

Source: https://context7.com/wowoengine/sawitdb/llms.txt

This code illustrates how to execute SQL queries with parameterized inputs in SawitDB for enhanced security and reusability. It shows the intended pattern for using parameter placeholders and provides an alternative for safe string interpolation, emphasizing input validation. Dependencies include a SawitDB instance. It defines functions for finding users by role, updating product prices, and safely inserting data.

```javascript
const db = new SawitDB('./secure.sawit');

// Note: Current implementation supports params array in query() signature
// though direct parameter substitution isn't fully implemented in QueryParser
// This example shows the intended usage pattern

// Query with parameter placeholders (intended pattern)
function findUsersByRole(role) {
    return db.query("PANEN * DARI users DIMANA role = ?", [role]);
}

function updateProductPrice(productId, newPrice) {
    return db.query("PUPUK products DENGAN price=? DIMANA id = ?", [newPrice, productId]);
}

// Alternative: String interpolation (use with caution - validate inputs!)
function safeInsert(tableName, data) {
    // Validate table name against whitelist
    const allowedTables = ['users', 'products', 'orders'];
    if (!allowedTables.includes(tableName)) {
        throw new Error('Invalid table name');
    }

    // Escape and validate data
    const keys = Object.keys(data).map(k => k.replace(/[^w]/g, '')).join(', ');
    const values = Object.values(data).map(v =>
        typeof v === 'string' ? `'${v.replace(/'/g, "''")}'` : v
    ).join(', ');

    return db.query(`TANAM KE ${tableName} (${keys}) BIBIT (${values})`);
}

// Usage
const admins = findUsersByRole('Admin');
updateProductPrice(42, 299.99);
safeInsert('users', {name: 'Bob', role: 'User', active: 1});

```

--------------------------------

### Network SawitDB Client Connection and Operations in JavaScript

Source: https://context7.com/wowoengine/sawitdb/llms.txt

Shows how to connect to a remote SawitDB server using the `sawitdb://` protocol, execute queries, switch databases, list available databases, check server latency, and drop databases. It utilizes the 'SawitClient' module and requires an asynchronous function context.

```javascript
const SawitClient = require('./src/SawitClient');

async function example() {
    // Connection string format: sawitdb://[username:password@]host:port/database
    const client = new SawitClient('sawitdb://localhost:7878/plantation');

    try {
        // Connect to server
        await client.connect();
        console.log('Connected to SawitDB server');

        // Create table
        await client.query('LAHAN sawit_trees');

        // Insert multiple records
        await client.query("TANAM KE sawit_trees (id, variety, age, yield) BIBIT (1, 'Tenera', 5, 120)");
        await client.query("TANAM KE sawit_trees (id, variety, age, yield) BIBIT (2, 'Dura', 3, 80)");
        await client.query("TANAM KE sawit_trees (id, variety, age, yield) BIBIT (3, 'Tenera', 7, 150)");

        // Query with complex conditions
        const results = await client.query("PANEN * DARI sawit_trees DIMANA variety = 'Tenera' AND age > 5");
        console.log(results);
        // Output: [{id: 3, variety: 'Tenera', age: 7, yield: 150}]

        // Switch database
        await client.use('analytics');

        // List all databases
        const databases = await client.listDatabases();
        console.log('Available databases:', databases);

        // Check connection latency
        const pingResult = await client.ping();
        console.log(`Server latency: ${pingResult.latency}ms`);

        // Drop database
        await client.dropDatabase('old_database');

    } catch (error) {
        console.error('Error:', error.message);
    } finally {
        client.disconnect();
    }
}

example();
```

--------------------------------

### Select Data Syntax (SQL)

Source: https://github.com/wowoengine/sawitdb/blob/main/README.md

Demonstrates the syntax for retrieving data from tables, including filtering, sorting, and limiting results. Supports both 'Tani' (AQL) and Generic SQL.

```sql
-- Tani
PANEN name, role DARI users DIMANA role = 'Admin' ORDER BY name ASC LIMIT 10
-- Generic
SELECT name, role FROM users WHERE role = 'Admin' ORDER BY name ASC LIMIT 10
```

--------------------------------

### SawitDB B-Tree Indexing for Performance

Source: https://context7.com/wowoengine/sawitdb/llms.txt

Explains how to create B-tree indexes in SawitDB to enhance query performance on specified fields. It covers creating indexes using both agricultural and generic SQL-like syntax, viewing existing indexes, and how queries on indexed fields are automatically optimized for faster lookups.

```javascript
const db = new SawitDB('./indexed.sawit');

// Create table and insert test data
db.query("LAHAN products");
for (let i = 1; i <= 1000; i++) {
    db.query(`TANAM KE products (id, sku, price) BIBIT (${i}, 'PROD-${i}', ${Math.random() * 1000})`);
}

// Create index on SKU field (Agricultural syntax)
const indexResult = db.query("INDEKS products PADA sku");
console.log(indexResult);
// Output: "Indeks dibuat pada 'products.sku' (1000 records indexed)"

// Create index with Generic syntax
db.query("CREATE INDEX ON products (price)");

// Show all indexes
const allIndexes = db.query("LIHAT INDEKS");
console.log(allIndexes);
// Output: [{name: 'products.sku', ...}, {name: 'products.price', ...}]

// Show indexes for specific table
const productIndexes = db.query("LIHAT INDEKS products");

// Queries on indexed fields are automatically optimized
const result = db.query("PANEN * DARI products DIMANA sku = 'PROD-500'");
// This query uses the B-Tree index for O(log n) lookup instead of O(n) table scan
```

--------------------------------

### Drop Table Syntax (SQL)

Source: https://github.com/wowoengine/sawitdb/blob/main/README.md

Illustrates how to delete a table and all its associated data using both 'Tani' (AQL) and Generic SQL commands. This operation is irreversible.

```sql
-- Tani
BAKAR LAHAN users
-- Generic
DROP TABLE users
```

--------------------------------

### Local Database Connection

Source: https://context7.com/wowoengine/sawitdb/llms.txt

Initialize and interact with a local SawitDB instance directly from your application using the `SawitDB` class.

```APIDOC
## Local Database Connection

### Description
This section details how to establish a connection to a local SawitDB instance and perform database operations using the `SawitDB` class. It supports both agricultural and generic SQL-like syntax for queries.

### Method
Instantiation of `SawitDB` class and subsequent `query` method calls.

### Endpoint
Not applicable (local file-based operations).

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```javascript
const SawitDB = require('./src/WowoEngine');
const path = require('path');

// Create or open database
const dbPath = path.join(__dirname, 'mydata.sawit');
const db = new SawitDB(dbPath);

// Create table (Agricultural syntax)
console.log(db.query("LAHAN products"));

// Insert data with Agricultural syntax
db.query("TANAM KE products (id, name, price, stock) BIBIT (1, 'Laptop', 1200, 50)");

// Select all records
const allProducts = db.query("PANEN * DARI products");
console.log(allProducts);

// Select with WHERE clause
const expensiveItems = db.query("PANEN * DARI products DIMANA price > 50");
console.log(expensiveItems);

// Update records
db.query("PUPUK products DENGAN stock=45 DIMANA id = 1");

// Delete records
db.query("GUSUR DARI products DIMANA stock < 100");

// Show all tables
console.log(db.query("LIHAT LAHAN"));
```

### Response
#### Success Response (200)
Responses vary based on the query executed. Examples include success messages for table creation, arrays of records for select queries, and count of affected rows for update/delete operations.

#### Response Example
```json
// Example for "LAHAN products"
"Kebun 'products' telah dibuka."

// Example for "PANEN * DARI products"
[
  {"id": 1, "name": "Laptop", "price": 1200, "stock": 50},
  {"id": 2, "name": "Mouse", "price": 25, "stock": 200},
  {"id": 3, "name": "Keyboard", "price": 75, "stock": 150}
]

// Example for "LIHAT LAHAN"
["products", "users"]
```
```

--------------------------------

### Aggregation and Grouping with SawitDB

Source: https://context7.com/wowoengine/sawitdb/llms.txt

Demonstrates how to perform aggregation and grouping operations on datasets using SawitDB. This includes statistical calculations such as COUNT, SUM, AVG, MIN, and MAX, along with filtering with WHERE clauses and grouping by specified fields. Assumes a SawitDB instance is initialized and connected.

```javascript
const db = new SawitDB('./analytics.sawit');

db.query("LAHAN sales");
db.query("TANAM KE sales (id, product, category, amount, region) BIBIT (1, 'Laptop', 'Electronics', 1200, 'North')");
db.query("TANAM KE sales (id, product, category, amount, region) BIBIT (2, 'Phone', 'Electronics', 800, 'South')");
db.query("TANAM KE sales (id, product, category, amount, region) BIBIT (3, 'Desk', 'Furniture', 350, 'North')");
db.query("TANAM KE sales (id, product, category, amount, region) BIBIT (4, 'Chair', 'Furniture', 150, 'South')");
db.query("TANAM KE sales (id, product, category, amount, region) BIBIT (5, 'Monitor', 'Electronics', 300, 'North')");

// COUNT all records
const total = db.query("HITUNG COUNT(*) DARI sales");
console.log(total);
// Output: {count: 5}

// SUM of amounts
const totalRevenue = db.query("HITUNG SUM(amount) DARI sales");
console.log(totalRevenue);
// Output: {sum: 2800, field: 'amount'}

// AVG calculation
const avgSale = db.query("HITUNG AVG(amount) DARI sales");
console.log(avgSale);
// Output: {avg: 560, field: 'amount', count: 5}

// MIN and MAX
const minSale = db.query("HITUNG MIN(amount) DARI sales");
const maxSale = db.query("HITUNG MAX(amount) DARI sales");
console.log(minSale); // {min: 150, field: 'amount'}
console.log(maxSale); // {max: 1200, field: 'amount'}

// GROUP BY category
const byCategory = db.query("HITUNG COUNT(*) DARI sales KELOMPOK category");
console.log(byCategory);
// Output: [{category: 'Electronics', count: 3}, {category: 'Furniture', count: 2}]

// SUM grouped by region
const revenueByRegion = db.query("HITUNG SUM(amount) DARI sales KELOMPOK region");
console.log(revenueByRegion);
// Output: [{region: 'North', sum: 1850}, {region: 'South', sum: 950}]

// AVG with WHERE filter
const electronicsAvg = db.query("HITUNG AVG(amount) DARI sales DIMANA category = 'Electronics'");
console.log(electronicsAvg);
// Output: {avg: 766.67, field: 'amount', count: 3}
```

--------------------------------

### SawitDB Advanced Query Operators and Syntax

Source: https://context7.com/wowoengine/sawitdb/llms.txt

Demonstrates advanced query capabilities in SawitDB, including the IN, NOT IN, LIKE, BETWEEN, IS NULL, IS NOT NULL operators, as well as sorting, limiting, and pagination using ORDER BY, LIMIT, and OFFSET. It also shows how to construct complex AND/OR conditions and perform data projection.

```javascript
const db = new SawitDB('./database.sawit');

// Setup test data
db.query("LAHAN employees");
db.query("TANAM KE employees (id, name, age, dept, salary) BIBIT (1, 'John Doe', 28, 'IT', 5000)");
db.query("TANAM KE employees (id, name, age, dept, salary) BIBIT (2, 'Jane Smith', 34, 'HR', 6000)");
db.query("TANAM KE employees (id, name, age, dept, salary) BIBIT (3, 'Bob Johnson', 45, 'IT', 7500)");
db.query("TANAM KE employees (id, name, age, dept, salary) BIBIT (4, 'Alice Brown', 29, 'Finance', 5500)");

// IN operator
const itAndHR = db.query("PANEN * DARI employees DIMANA dept IN ('IT', 'HR')");
console.log(itAndHR);

// NOT IN operator
const notIT = db.query("PANEN * DARI employees DIMANA dept NOT IN ('IT')");

// LIKE pattern matching (% wildcard)
const johnsons = db.query("PANEN * DARI employees DIMANA name LIKE '%Johnson'");

// BETWEEN range query
const midAge = db.query("PANEN * DARI employees DIMANA age BETWEEN 30 AND 40");
console.log(midAge);
// Output: [{id: 2, name: 'Jane Smith', age: 34, ...}]

// IS NULL / IS NOT NULL
db.query("TANAM KE employees (id, name, age) BIBIT (5, 'Incomplete', 25)");
const missingDept = db.query("PANEN * DARI employees DIMANA dept IS NULL");
const hasDept = db.query("PANEN * DARI employees DIMANA dept IS NOT NULL");

// ORDER BY with LIMIT and OFFSET (pagination)
const page1 = db.query("PANEN * DARI employees ORDER BY salary DESC LIMIT 2 OFFSET 0");
console.log(page1);
// Output: Top 2 highest salaries

const page2 = db.query("PANEN * DARI employees ORDER BY salary DESC LIMIT 2 OFFSET 2");
// Next 2 records

// Complex AND/OR conditions
const seniorITorHighSalary = db.query(
    "PANEN * DARI employees DIMANA (age > 40 AND dept = 'IT') OR salary > 6000"
);

// Projection (select specific columns)
const namesOnly = db.query("PANEN name, dept DARI employees DIMANA age < 30");
console.log(namesOnly);
// Output: [{name: 'John Doe', dept: 'IT'}, {name: 'Alice Brown', dept: 'Finance'}]
```

--------------------------------

### Monitor SawitDB Server Statistics and Health (JavaScript)

Source: https://context7.com/wowoengine/sawitdb/llms.txt

This snippet demonstrates how to monitor server performance metrics, connection statistics, and resource usage for a SawitDB instance. It connects to the database, retrieves statistics, pings the server for latency, and sets up a health check interval. Dependencies include the './src/SawitClient' module. It outputs server statistics and ping latency.

```javascript
const SawitClient = require('./src/SawitClient');

async function monitorServer() {
    const client = new SawitClient('sawitdb://admin:secretpass@localhost:7878/default');
    await client.connect();

    // Get server statistics
    const stats = await client.stats();
    console.log('Server Statistics:', stats);
    /* Output:
    {
        totalConnections: 150,
        activeConnections: 12,
        totalQueries: 45238,
        errors: 3,
        startTime: 1704268800000,
        uptime: 3600000,
        uptimeFormatted: '1h 0m',
        databases: 5,
        memoryUsage: {
            rss: 52428800,
            heapTotal: 20971520,
            heapUsed: 15728640,
            external: 1048576
        }
    }
    */

    // Ping server to check latency
    const ping = await client.ping();
    console.log(`Ping: ${ping.latency}ms`);
    console.log(`Server time: ${new Date(ping.serverTime)}`);

    // Health check loop
    setInterval(async () => {
        try {
            const health = await client.ping();
            if (health.latency > 100) {
                console.warn('High latency detected:', health.latency);
            }
        } catch (error) {
            console.error('Health check failed:', error.message);
        }
    }, 30000); // Check every 30 seconds
}

monitorServer();

```

--------------------------------

### Update Data Syntax (SQL)

Source: https://github.com/wowoengine/sawitdb/blob/main/README.md

Illustrates the commands for modifying existing data in a table, using both 'Tani' (AQL) and Generic SQL syntaxes. Updates are atomic.

```sql
-- Tani
PUPUK users DENGAN role='SuperAdmin' DIMANA name='Alice'
-- Generic
UPDATE users SET role='SuperAdmin' WHERE name='Alice'
```

--------------------------------

### SawitDB Operators

Source: https://github.com/wowoengine/sawitdb/blob/main/docs/index.html

SawitDB supports a variety of operators for data manipulation and querying, including comparison, logical, list inclusion, pattern matching, range checks, null checks, and pagination.

```AQL
=
!= 
>
<
>=
<=
AND
OR
IN ('coffee', 'tea')
LIKE 'Jwa%'
BETWEEN 10 AND 50
IS NULL
IS NOT NULL
LIMIT 10 OFFSET 5
```

--------------------------------

### Delete Data Syntax (SQL)

Source: https://github.com/wowoengine/sawitdb/blob/main/README.md

Shows the syntax for removing data records from a table based on specified conditions, available in both 'Tani' (AQL) and Generic SQL.

```sql
-- Tani
GUSUR DARI users DIMANA name='Bob'
-- Generic
DELETE FROM users WHERE name='Bob'
```

--------------------------------

### Network Client Connection

Source: https://context7.com/wowoengine/sawitdb/llms.txt

Connect to a remote SawitDB server using the `SawitClient` class, supporting TCP protocol, authentication, and database switching.

```APIDOC
## Network Client Connection

### Description
This section describes how to connect to a remote SawitDB server using the `SawitClient` class. It utilizes a TCP-based client-server architecture with the `sawitdb://` protocol and supports authentication, database selection, and various query operations.

### Method
Instantiation of `SawitClient` class and subsequent asynchronous method calls like `connect`, `query`, `use`, `listDatabases`, `ping`, `dropDatabase`, and `disconnect`.

### Endpoint
The endpoint is defined by the connection string URI: `sawitdb://[username:password@]host:port/database`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```javascript
const SawitClient = require('./src/SawitClient');

async function example() {
    // Connection string format: sawitdb://[username:password@]host:port/database
    const client = new SawitClient('sawitdb://localhost:7878/plantation');

    try {
        // Connect to server
        await client.connect();
        console.log('Connected to SawitDB server');

        // Create table
        await client.query('LAHAN sawit_trees');

        // Insert multiple records
        await client.query("TANAM KE sawit_trees (id, variety, age, yield) BIBIT (1, 'Tenera', 5, 120)");

        // Query with complex conditions
        const results = await client.query("PANEN * DARI sawit_trees DIMANA variety = 'Tenera' AND age > 5");
        console.log(results);

        // Switch database
        await client.use('analytics');

        // List all databases
        const databases = await client.listDatabases();
        console.log('Available databases:', databases);

        // Check connection latency
        const pingResult = await client.ping();
        console.log(`Server latency: ${pingResult.latency}ms`);

        // Drop database
        await client.dropDatabase('old_database');

    } catch (error) {
        console.error('Error:', error.message);
    } finally {
        client.disconnect();
    }
}

example();
```

### Response
#### Success Response (200)
Responses are typically JSON objects or arrays representing query results, status messages, or lists of available databases. The `ping` method returns an object with latency information.

#### Response Example
```json
// Example for "PANEN * DARI sawit_trees DIMANA variety = 'Tenera' AND age > 5"
[
  {"id": 3, "variety": "Tenera", "age": 7, "yield": 150}
]

// Example for listDatabases()
["plantation", "analytics", "users_data"]

// Example for ping()
{
  "status": "success",
  "latency": 5
}
```
```

--------------------------------

### Tailwind CSS Configuration (JavaScript)

Source: https://github.com/wowoengine/sawitdb/blob/main/docs/index.html

Customizes Tailwind CSS by extending the default theme with custom fonts and a color palette named 'sawit'.

```javascript
tailwind.config = {
  theme: {
    extend: {
      fontFamily: {
        sans: ['Inter', 'sans-serif'],
      },
      colors: {
        sawit: {
          50: '#f0fdf4',
          100: '#dcfce7',
          500: '#22c55e',
          600: '#16a34a',
          700: '#15803d',
          800: '#166534',
          900: '#14532d',
        }
      }
    }
  }
}
```

--------------------------------

### Custom Scrollbar CSS (CSS)

Source: https://github.com/wowoengine/sawitdb/blob/main/docs/index.html

Defines CSS rules to hide the scrollbar for webkit browsers (like Chrome and Safari) and for Firefox.

```css
/* Custom scrollbar for sidebar */
.scrollbar-hide::-webkit-scrollbar {
  display: none;
}

.scrollbar-hide {
  -ms-overflow-style: none; /* IE and Edge */
  scrollbar-width: none; /* Firefox */
}
```
Tokens:
Raw