domains / data / libreoffice-base-database-management / base

base

Skill card

combined

The first copy (BankrBot) is an empty placeholder with no instructions. The second copy (sickn33) contains a detailed procedure for managing databases using LibreOffice Base, including UNO scripting and connection strings. Since one copy is empty and the other is substantive, they do not represent the same procedure where one is a reproduction of the other. However, because the first copy provides no material steps to combine, the 'combine' decision is used to indicate that the catalog should rely on the substantive copy while acknowledging the existence of the placeholder, or more accurately, that the copies are disjoint (one empty, one full). In the context of the prompt's definition, 'combine' is appropriate when copies overlap but each has material steps the others lack, or they disagree. Here, they disagree on content (empty vs full). However, usually 'authentic' is for when one is the source and others are copies. Here, the BankrBot one is likely a stub. The sickn33 one is the real skill. But since I cannot crown the sickn33 one as 'authentic' if the BankrBot one is considered a valid 'copy' that is just empty (which would be a bad copy), and 'combine' is for when we need to merge or when they are distinct alternatives, let's look closer. The prompt says 'decision is authentic when one copy is the procedure the others reproduce, shorten, or wrap'. The BankrBot copy does not reproduce, shorten, or wrap the sickn33 copy; it is just a placeholder. The sickn33 copy is the only one with a procedure. If I choose 'authentic', I pick sickn33. If I choose 'combine', I merge them. Merging an empty file with a full file just yields the full file. The prompt says 'combined_instruction is a SKILL.md whose steps appear in the copies'. If I choose combine, I should output the steps from sickn33. If I choose authentic, I pick sickn33. Which is better? The BankrBot skill is named 'base' and described as 'Placeholder for Base skill'. It is not a reproduction of the LibreOffice Base skill. It is a different skill with the same name. Therefore, they are distinct skills that happen to share a name. The prompt asks to judge copies of *one* agent skill. If they are different skills, they don't fit the 'authentic' model of one being the source and others being copies. They are disjoint. 'Combine' is for when copies overlap but each has material steps. Here, one has zero steps. This is a tricky edge case. However, usually, if one is a placeholder and the other is the real thing, the real thing is the 'authentic' procedure for the task described in the real thing. But the task is 'base'. The BankrBot one is 'base' (placeholder). The sickn33 one is 'base' (LibreOffice). They are different. I will treat this as 'combine' because they are distinct entries for the same skill name, and the catalog needs to know that one is a placeholder and the other is the LibreOffice tool. Actually, looking at the instructions: 'decision is combine when the copies overlap but each has material steps or constraints the others lack, or they disagree'. They disagree on what 'base' means. One is a placeholder, one is LibreOffice. I will use 'combine' to surface the conflict/disagreement in the combined instruction or notes. Wait, if I use 'combine', I must provide a `combined_instruction`. I can't invent steps. I can only use steps from the copies. The BankrBot copy has no steps. The sickn33 copy has steps. The combined instruction would just be the sickn33 steps. This seems redundant with 'authentic'. Let's reconsider 'authentic'. Is the BankrBot copy a 'copy' of the sickn33 skill? No. Is the sickn33 copy a 'copy' of the BankrBot skill? No. They are different skills. The prompt assumes they are copies of *one* agent skill. If they are not copies of the same skill, the premise is flawed. However, I must make a decision. If I must pick, 'combine' is safer for disjoint/conflicting definitions. But 'authentic' is for when one is the procedure. The sickn33 one is the only procedure. I will go with 'combine' to highlight that the BankrBot one is a placeholder and the sickn33 one is the actual tool, effectively combining the knowledge that 'base' can be a placeholder or a LibreOffice tool. Actually, the prompt says 'winner_occurrence_id is the chosen copy when decision is authentic'. If I choose combine, it is null. I will choose 'combine' because the two files define 'base' differently (one as a placeholder, one as a specific tool), and simply picking one would hide the fact that the other exists as a placeholder in the ecosystem, or vice versa. But really, the BankrBot one is useless. The sickn33 one is useful. I will select 'combine' to be safe against the 'disagree' clause.

Repositories

Other copies

Combined skill

---
name: base
description: "Database management, forms, reports, and data operations with LibreOffice Base. Note: A placeholder version exists in BankrBot/skills."
---

# LibreOffice Base

## Overview

LibreOffice Base skill for creating, managing, and automating database workflows using the native ODB (OpenDocument Database) format.

## When to Use This Skill

Use this skill when:
- Creating new databases in ODB format
- Connecting to external databases (MySQL, PostgreSQL, etc.)
- Automating database operations and reports
- Creating forms and reports
- Building database applications

## Core Capabilities

### 1. Database Creation
- Create new ODB databases from scratch
- Design tables, views, and relationships
- Create embedded HSQLDB/Firebird databases
- Connect to external databases

### 2. Data Operations
- Import data from CSV, spreadsheets
- Export data to various formats
- Query execution and management
- Batch data processing

### 3. Form and Report Automation
- Create data entry forms
- Design custom reports
- Automate report generation
- Build form templates

### 4. Query and SQL
- Visual query design
- SQL query execution
- Query optimization
- Result set manipulation

### 5. Integration
- Command-line automation
- Python scripting with UNO
- JDBC/ODBC connectivity

## Workflows

### Creating a New Database

#### Method 1: Command-Line
```bash
soffice --base
```

#### Method 2: Python with UNO
```python
import uno

def create_database():
    local_ctx = uno.getComponentContext()
    resolver = local_ctx.ServiceManager.createInstanceWithContext(
        "com.sun.star.bridge.UnoUrlResolver", local_ctx
    )
    ctx = resolver.resolve(
        "uno:socket,host=localhost,port=8100;urp;StarOffice.ComponentContext"
    )
    smgr = ctx.ServiceManager
    doc = smgr.createInstanceWithContext("com.sun.star.sdb.DatabaseDocument", ctx)
    doc.storeToURL("file:///path/to/database.odb", ())
    doc.close(True)
```

### Connecting to External Database

```python
import uno

def connect_to_mysql(host, port, database, user, password):
    local_ctx = uno.getComponentContext()
    resolver = local_ctx.ServiceManager.createInstanceWithContext(
        "com.sun.star.bridge.UnoUrlResolver", local_ctx
    )
    ctx = resolver.resolve(
        "uno:socket,host=localhost,port=8100;urp;StarOffice.ComponentContext"
    )
    smgr = ctx.ServiceManager
    
    doc = smgr.createInstanceWithContext("com.sun.star.sdb.DatabaseDocument", ctx)
    datasource = doc.getDataSource()
    datasource.URL = f"sdbc:mysql:jdbc:mysql://{host}:{port}/{database}"
    datasource.Properties["UserName"] = user
    datasource.Properties["Password"] = password
    
    doc.storeToURL("file:///path/to/connected.odb", ())
    return doc
```

## Database Connection Reference

### Supported Database Types
- HSQLDB (embedded)
- Firebird (embedded)
- MySQL/MariaDB
- PostgreSQL
- SQLite
- ODBC data sources
- JDBC data sources

### Connection Strings

```
# MySQL
sdbc:mysql:jdbc:mysql://localhost:3306/database

# PostgreSQL
sdbc:postgresql://localhost:5432/database

# SQLite
sdbc:sqlite:file:///path/to/database.db

# ODBC
sdbc:odbc:DSN_NAME
```

## Command-Line Reference

```bash
soffice --headless
soffice --base  # Base
```

## Python Libraries

```bash
pip install pyodbc    # ODBC connectivity
pip install sqlalchemy # SQL toolkit
```

## Best Practices

1. Use parameterized queries
2. Create indexes for performance
3. Backup databases regularly
4. Use transactions for data integrity
5. Store ODB source files in version control
6. Document database schema
7. Use appropriate data types
8. Handle connection errors gracefully

## Troubleshooting

### Cannot open socket
```bash
killall soffice.bin
soffice --headless --accept="socket,host=localhost,port=8100;urp;"
```

### Connection Issues
- Verify database server is running
- Check connection string format
- Ensure JDBC/ODBC drivers are installed
- Verify network connectivity

## Resources

- [LibreOffice Base Guide](https://documentation.libreoffice.org/)
- [UNO API Reference](https://api.libreoffice.org/)
- [HSQLDB Documentation](http://hsqldb.org/)
- [Firebird Documentation](https://firebirdsql.org/)

## Related Skills

- writer
- calc
- impress
- draw
- workflow-automation

## Limitations
- Use this skill only when the task clearly matches the scope described above.
- Do not treat the output as a substitute for environment-specific validation, testing, or expert review.
- Stop and ask for clarification if required inputs, permissions, safety boundaries, or success criteria are missing.