Command Style (Use PATH)

All examples use the plain command name

dbcli

(no directory prefix). Ensure

dbcli

is on PATH instead of hardcoding paths like

.\.claude\skills\dbcli\dbcli.exe

.

DbCli Tables Skill

List all tables and view table structures in databases.

When to Use This Skill

• User wants to see all tables in a database
• User needs to check table structure or schema
• User asks "what tables exist" or "show me the database schema"
• User wants to see column names, types, or constraints
• User needs to explore an unfamiliar database

Command Syntax

List All Tables

dbcli -c "CONNECTION_STRING" [-t DATABASE_TYPE] [-f FORMAT] tables

Show Table Structure

dbcli -c "CONNECTION_STRING" [-t DATABASE_TYPE] [-f FORMAT] columns TABLE_NAME

Global Options

• -c, --connection

  : Database connection string (required)

• -t, --db-type

  : Database type (default: sqlite)

• -f, --format

  : Output format:

  json

  (default),

  table

  ,

  csv

List All Tables

Basic Usage

# SQLite - JSON format (default)
dbcli -c "Data Source=app.db" tables

# Output: [{"TableName":"Users"},{"TableName":"Orders"},{"TableName":"Products"}]

# Table format (human-readable)
dbcli -c "Data Source=app.db" -f table tables

# Output:
# +-----------+
# | TableName |
# +-----------+
# | Users     |
# | Orders    |
# | Products  |
# +-----------+

Different Databases

# SQL Server
dbcli -c "Server=localhost;Database=mydb;Trusted_Connection=True" -t sqlserver -f table tables

# MySQL
dbcli -c "Server=localhost;Database=mydb;Uid=root;Pwd=xxxxxxxxxx" -t mysql -f table tables

# PostgreSQL
dbcli -c "Host=localhost;Database=mydb;Username=postgres;Password=xxxxxxxxxx" -t postgresql -f table tables

# Oracle
dbcli -c "Data Source=localhost:1521/orcl;User Id=system;Password=xxxxxxxxxx" -t oracle -f table tables

# MongoDB
dbcli -c "mongodb://localhost:27017/mydb" -t mongodb -f table tables

Chinese Domestic Databases

# DaMeng (达梦)
dbcli -c "Server=localhost;User Id=SYSDBA;PWD=xxxxxxxxxx;DATABASE=mydb" -t dm -f table tables

# KingbaseES (人大金仓)
dbcli -c "Server=localhost;Port=54321;UID=system;PWD=xxxxxxxxxx;database=mydb" -t kdbndp -f table tables

# GaussDB
dbcli -c "Host=localhost;Port=8000;Database=mydb;Username=gaussdb;Password=xxxxxxxxxx" -t gaussdb -f table tables

Show Table Structure

Basic Column Information

# SQLite - Show Users table structure
dbcli -c "Data Source=app.db" -f table columns Users

# Output:
# +------------+----------+--------+------------+--------------+--------------+
# | ColumnName | DataType | Length | IsNullable | IsPrimaryKey | DefaultValue |
# +------------+----------+--------+------------+--------------+--------------+
# | Id         | INTEGER  | 0      | False      | True         |              |
# | Name       | TEXT     | 0      | False      | False        |              |
# | Email      | TEXT     | 0      | True       | False        |              |
# | CreatedAt  | TIMESTAMP| 0      | True       | False        | CURRENT_TIME |
# +------------+----------+--------+------------+--------------+--------------+

JSON Output

# Get column info as JSON for programmatic use
dbcli -c "Data Source=app.db" columns Users

# Output: [
#   {"ColumnName":"Id","DataType":"INTEGER","Length":0,"IsNullable":false,"IsPrimaryKey":true,"DefaultValue":""},
#   {"ColumnName":"Name","DataType":"TEXT","Length":0,"IsNullable":false,"IsPrimaryKey":false,"DefaultValue":""},
#   ...
# ]

Multiple Tables

# Check structure of multiple tables
for table in Users Orders Products; do
    echo "=== $table ==="
    dbcli -c "Data Source=app.db" -f table columns $table
    echo
done

Use Cases

1. Database Discovery

# First, see what tables exist
dbcli -c "Data Source=unknown.db" -f table tables

# Then examine interesting tables
dbcli -c "Data Source=unknown.db" -f table columns Users
dbcli -c "Data Source=unknown.db" -f table columns Orders

2. Schema Documentation

#!/bin/bash
# Generate schema documentation

CONNECTION="Data Source=app.db"
OUTPUT="schema_doc.txt"

echo "Database Schema Documentation" > $OUTPUT
echo "Generated: $(date)" >> $OUTPUT
echo >> $OUTPUT

# List all tables
echo "=== Tables ===" >> $OUTPUT
dbcli -c "$CONNECTION" -f table tables >> $OUTPUT
echo >> $OUTPUT

# Get structure for each table
dbcli -c "$CONNECTION" tables | jq -r '.[].TableName' | while read table; do
    echo "=== Table: $table ===" >> $OUTPUT
    dbcli -c "$CONNECTION" -f table columns $table >> $OUTPUT
    echo >> $OUTPUT
done

echo "Documentation saved to $OUTPUT"

3. Verify Table Exists

# Check if specific table exists
if dbcli -c "Data Source=app.db" tables | jq -r '.[].TableName' | grep -q "^Users$"; then
    echo "Users table exists"
else
    echo "Users table not found"
fi

4. Find Tables by Pattern

# Find all tables starting with "temp_"
dbcli -c "Data Source=app.db" tables | jq -r '.[].TableName' | grep "^temp_"

5. Column Validation

# Check if Email column exists in Users table
if dbcli -c "Data Source=app.db" columns Users | jq -r '.[].ColumnName' | grep -q "^Email$"; then
    echo "Email column exists"
else
    echo "Email column missing - need to add it"
fi

6. Primary Key Detection

# Find primary key column(s)
dbcli -c "Data Source=app.db" columns Users | jq -r '.[] | select(.IsPrimaryKey == true) | .ColumnName'

# Output: Id

7. Nullable Column Check

# List all nullable columns
dbcli -c "Data Source=app.db" columns Users | jq -r '.[] | select(.IsNullable == true) | .ColumnName'

Programmatic Usage

Python - List All Tables

import subprocess
import json

result = subprocess.run([
    'dbcli', '-c', 'Data Source=app.db',
    'tables'
], capture_output=True, text=True)

tables = json.loads(result.stdout)
for table in tables:
    print(f"Table: {table['TableName']}")

Python - Inspect Schema

import subprocess
import json

def get_table_info(connection, table_name):
    """Get detailed table information"""
    result = subprocess.run([
        'dbcli', '-c', connection,
        'columns', table_name
    ], capture_output=True, text=True)

    columns = json.loads(result.stdout)

    print(f"\nTable: {table_name}")
    print(f"Total columns: {len(columns)}")

    print("\nPrimary Keys:")
    for col in columns:
        if col['IsPrimaryKey']:
            print(f"  - {col['ColumnName']} ({col['DataType']})")

    print("\nNullable Columns:")
    for col in columns:
        if col['IsNullable']:
            print(f"  - {col['ColumnName']}")

# Usage
get_table_info('Data Source=app.db', 'Users')

Node.js - Schema Exploration

const { execSync } = require('child_process');

function exploreDatabaseSchema(connection) {
    // Get all tables
    const tablesJson = execSync(`dbcli -c "${connection}" tables`).toString();
    const tables = JSON.parse(tablesJson);

    console.log(`Found ${tables.length} tables:\n`);

    tables.forEach(table => {
        console.log(`Table: ${table.TableName}`);

        // Get columns for each table
        const columnsJson = execSync(
            `dbcli -c "${connection}" columns ${table.TableName}`
        ).toString();
        const columns = JSON.parse(columnsJson);

        columns.forEach(col => {
            const pk = col.IsPrimaryKey ? ' [PK]' : '';
            const nullable = col.IsNullable ? ' [NULL]' : ' [NOT NULL]';
            console.log(`  - ${col.ColumnName}: ${col.DataType}${pk}${nullable}`);
        });

        console.log();
    });
}

// Usage
exploreDatabaseSchema('Data Source=app.db');

PowerShell - Schema Comparison

function Compare-DatabaseSchemas {
    param(
        [string]$Connection1,
        [string]$Connection2
    )

    $tables1 = dbcli -c $Connection1 tables | ConvertFrom-Json | Select-Object -ExpandProperty TableName
    $tables2 = dbcli -c $Connection2 tables | ConvertFrom-Json | Select-Object -ExpandProperty TableName

    Write-Host "Tables only in Database 1:"
    $tables1 | Where-Object { $_ -notin $tables2 }

    Write-Host "`nTables only in Database 2:"
    $tables2 | Where-Object { $_ -notin $tables1 }

    Write-Host "`nCommon tables:"
    $common = $tables1 | Where-Object { $_ -in $tables2 }
    $common

    # Compare column structure for common tables
    foreach ($table in $common) {
        $cols1 = dbcli -c $Connection1 columns $table | ConvertFrom-Json
        $cols2 = dbcli -c $Connection2 columns $table | ConvertFrom-Json

        if (Compare-Object $cols1 $cols2 -Property ColumnName, DataType) {
            Write-Host "`nDifference in table: $table"
        }
    }
}

# Usage
Compare-DatabaseSchemas -Connection1 "Data Source=db1.db" -Connection2 "Data Source=db2.db"

Output Formats

JSON Format (Default)

dbcli -c "Data Source=app.db" tables
# [{"TableName":"Users"},{"TableName":"Orders"}]

dbcli -c "Data Source=app.db" columns Users
# [{"ColumnName":"Id","DataType":"INTEGER","Length":0,...},...]

Table Format (Human-Readable)

dbcli -c "Data Source=app.db" -f table tables
# +-----------+
# | TableName |
# +-----------+
# | Users     |
# +-----------+

dbcli -c "Data Source=app.db" -f table columns Users
# +------------+----------+--------+------------+--------------+
# | ColumnName | DataType | Length | IsNullable | IsPrimaryKey |
# +------------+----------+--------+------------+--------------+

CSV Format

dbcli -c "Data Source=app.db" -f csv tables > tables.csv
# TableName
# Users
# Orders

dbcli -c "Data Source=app.db" -f csv columns Users > users_schema.csv
# ColumnName,DataType,Length,IsNullable,IsPrimaryKey,DefaultValue
# Id,INTEGER,0,False,True,
# Name,TEXT,0,False,False,

Common Patterns

Quick Table Count

dbcli -c "Data Source=app.db" tables | jq '. | length'

Find Large Tables

# List tables with row counts
dbcli -c "Data Source=app.db" tables | jq -r '.[].TableName' | while read table; do
    count=$(dbcli -c "Data Source=app.db" query "SELECT COUNT(*) as cnt FROM $table" | jq -r '.[0].cnt')
    echo "$table: $count rows"
done

Generate CREATE TABLE from Existing

# SQLite - Get original CREATE statement
dbcli -c "Data Source=app.db" query "SELECT sql FROM sqlite_master WHERE type='table' AND name='Users'"

Schema Diff Tool

#!/bin/bash
# schema_diff.sh - Compare two database schemas

DB1="$1"
DB2="$2"

echo "Comparing schemas: $DB1 vs $DB2"

# Compare table lists
diff <(dbcli -c "Data Source=$DB1" tables | jq -r '.[].TableName' | sort) \
     <(dbcli -c "Data Source=$DB2" tables | jq -r '.[].TableName' | sort)

Integration with Other Skills

Use with Query Skill

# First, find all tables
tables=$(dbcli -c "Data Source=app.db" tables | jq -r '.[].TableName')

# Then query each table
for table in $tables; do
    echo "=== Sample from $table ==="
    dbcli -c "Data Source=app.db" -f table query "SELECT * FROM $table LIMIT 3"
done

Use with Export Skill

# Export all tables found in database
dbcli -c "Data Source=app.db" tables | jq -r '.[].TableName' | while read table; do
    echo "Exporting $table..."
    dbcli -c "Data Source=app.db" export $table > "${table}_backup.sql"
done