ddlglot 26.3.0__tar.gz

ddlglot-26.3.0/.github/pull_request_template.md

@@ -0,0 +1,25 @@
+## Description
+
+<!-- Describe your changes -->
+
+## Type of Change
+
+- [ ] Bug fix
+- [ ] New feature
+- [ ] Breaking change
+- [ ] Documentation update
+- [ ] Refactoring
+
+## Checklist
+
+- [ ] My code follows the style guidelines
+- [ ] I have performed a self-review
+- [ ] I have commented my code where necessary
+- [ ] I have updated the documentation
+- [ ] My changes generate no new warnings
+- [ ] I have added tests that prove my fix is effective
+- [ ] New and existing tests pass locally
+
+## Related Issue
+
+<!-- Link to related issue (e.g., "Closes #123") -->

ddlglot-26.3.0/.github/workflows/ci.yml

@@ -0,0 +1,86 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  test:
+    name: Test
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.13"
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v4
+        with:
+          enable-cache: true
+
+      - name: Install dependencies
+        run: uv sync --all-extras
+
+      - name: Lint
+        run: uv run ruff check src tests
+
+      - name: Format check
+        run: uv run ruff format --check src tests
+
+      - name: Type check
+        run: uv run mypy src
+
+      - name: Run tests
+        run: uv run pytest tests --cov=ddlglot --cov-report=term-missing --cov-report=xml
+
+      - name: Upload coverage
+        uses: actions/upload-artifact@v4
+        with:
+          name: coverage
+          path: coverage.xml
+          retention-days: 1
+
+      - name: Upload to Codecov
+        uses: codecov/codecov-action@v4
+        with:
+          files: coverage.xml
+        continue-on-error: true
+
+  build:
+    name: Build
+    needs: test
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.13"
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v4
+
+      - name: Install build
+        run: uv pip install --system build hatch
+
+      - name: Build package
+        run: python -m build
+
+      - name: Verify build
+        run: |
+          pip install dist/*.whl --force-reinstall
+          python -c "import ddlglot; print('ddlglot imported successfully')"
+
+      - name: Upload artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: dist
+          path: dist/
+          retention-days: 5

ddlglot-26.3.0/.github/workflows/release.yml

@@ -0,0 +1,71 @@
+name: Release
+
+on:
+  push:
+    tags:
+      - "v*"
+
+jobs:
+  test:
+    name: Test before release
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.13"
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v4
+
+      - name: Install dependencies
+        run: uv sync --all-extras
+
+      - name: Lint
+        run: uv run ruff check src tests
+
+      - name: Type check
+        run: uv run mypy src
+
+      - name: Run tests
+        run: uv run pytest tests --cov=ddlglot
+
+  release:
+    name: Publish to PyPI
+    needs: test
+    runs-on: ubuntu-latest
+    environment:
+      name: pypi
+      url: https://pypi.org/project/ddlglot/
+    permissions:
+      id-token: write
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.13"
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v4
+
+      - name: Install build
+        run: uv pip install --system build hatch
+
+      - name: Build package
+        run: python -m build
+
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+
+      - name: Create GitHub Release
+        uses: softprops/action-gh-release@v2
+        with:
+          files: dist/*
+          generate_release_notes: true
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

ddlglot-26.3.0/.gitignore

@@ -0,0 +1,5 @@
+.venv/
+__pycache__/
+*.pyc
+.git/
+

ddlglot-26.3.0/.pre-commit-config.yaml

@@ -0,0 +1,16 @@
+repos:
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v4.5.0
+    hooks:
+      - id: trailing-whitespace
+      - id: end-of-file-fixer
+      - id: check-yaml
+      - id: check-added-large-files
+      - id: check-toml
+
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: v0.1.8
+    hooks:
+      - id: ruff
+        args: [--fix]
+      - id: ruff-format

ddlglot-26.3.0/.python-version

@@ -0,0 +1 @@
+3.13

ddlglot-26.3.0/AGENTS.md

@@ -0,0 +1,248 @@
+# AGENTS.md - Developer Guide for ddlglot
+
+## Overview
+
+`ddlglot` is a Python library that provides a fluent builder API for generating DDL (Data Definition Language) statements using SQLGlot's AST. It supports multiple SQL dialects (PostgreSQL, SQLite, DuckDB, Spark/Delta Lake, etc.).
+
+---
+
+## 1. Commands
+
+### Build & Install
+
+```bash
+# Install the package in editable mode
+pip install -e .
+
+# Build the package
+hatch build
+```
+
+### Testing
+
+```bash
+# Run all tests
+pytest
+
+# Run a single test file
+pytest tests/test_core.py
+
+# Run a single test function
+pytest tests/test_core.py::test_create_table_basic
+
+# Run tests with verbose output
+pytest -v
+
+# Run tests with coverage
+pytest --cov=ddlglot --cov-report=term-missing
+```
+
+### Linting & Type Checking
+
+```bash
+# Run ruff (linter + formatter)
+ruff check .
+ruff format .
+
+# Run mypy (type checking)
+mypy src/ddlglot
+```
+
+---
+
+## 2. Code Style Guidelines
+
+### General
+
+- **Language**: English for all code, comments, and documentation
+- **Python version**: 3.13+
+- **Build system**: hatchling (via `pyproject.toml`)
+
+### Imports
+
+```python
+# Standard library first
+from __future__ import annotations
+from typing import Any, Dict, List, Optional, Tuple, Union
+
+# Third-party packages
+from sqlglot import expressions as exp
+
+# Local modules
+from ddlglot.builder import CreateBuilder, create
+from ddlglot.variants.spark_delta import create_spark_delta
+```
+
+- Use `from __future__ import annotations` for forward references
+- Always use explicit relative imports for package modules (`from ..builder import ...`)
+- Alphabetize imports within each group
+
+### Formatting
+
+- **Line length**: 100 characters max
+- **Indentation**: 4 spaces (no tabs)
+- **Quotes**: Double quotes for strings, except when string contains double quotes
+- **Trailing commas**: Use in multi-line expressions
+
+```python
+# Good
+def example(
+    arg1: str,
+    arg2: int,
+) -> Dict[str, Any]:
+    return {"arg1": arg1, "arg2": arg2}
+
+# Bad
+def example(arg1: str, arg2: int) -> Dict[str, Any]:
+    return {"arg1": arg1, "arg2": arg2}
+```
+
+### Types
+
+- Use explicit type hints for all function parameters and return types
+- Use `Optional[X]` instead of `X | None` for Python < 3.10 compatibility
+- Prefer type aliases for complex types:
+
+```python
+Lit = Union[str, int, float, bool]
+```
+
+### Naming Conventions
+
+| Element | Convention | Example |
+|---------|------------|---------|
+| Modules | snake_case | `spark_delta.py` |
+| Classes | PascalCase | `CreateBuilder` |
+| Functions | snake_case | `create()`, `to_ast()` |
+| Variables | snake_case | `self._table` |
+| Constants | UPPER_SNAKE_CASE | `DELTA_FORMAT` |
+| Private members | `_leading_underscore` | `self._columns` |
+
+### Classes & Methods
+
+- Use fluent builder pattern: methods return `self` for chaining
+- Use `__init__` for object construction
+- Use `@staticmethod` for pure utility functions
+
+```python
+class CreateBuilder:
+    def name(self, table: str) -> "CreateBuilder":
+        self._table = table
+        return self
+```
+
+### Error Handling
+
+- Use explicit exceptions with descriptive messages
+- Raise `ValueError` for invalid arguments
+
+```python
+def to_ast(self) -> exp.Create:
+    if not self._table:
+        raise ValueError("Falta .name(<tabla>)")
+```
+
+### Docstrings
+
+- Use Google-style docstrings for public APIs:
+
+```python
+def sql(self, dialect: Optional[str] = None, pretty: bool = False) -> str:
+    """Generate SQL DDL string.
+    
+    Args:
+        dialect: SQL dialect (e.g., "postgres", "spark").
+        pretty: Enable pretty formatting.
+    
+    Returns:
+        The generated SQL string.
+    """
+    return self.to_ast().sql(dialect=dialect, pretty=pretty)
+```
+
+- **Do not add comments** unless explicitly requested
+
+### Testing
+
+- Place tests in `tests/` directory
+- Use `pytest` as test runner
+- Follow naming: `test_<module>.py`
+- One test class per module, test functions prefixed with `test_`
+
+```python
+# tests/test_core.py
+import pytest
+from ddlglot import create
+
+def test_create_table_basic():
+    sql = (
+        create("table")
+        .name("public.users")
+        .column("id", "INT", not_null=True)
+        .sql(dialect="postgres")
+    )
+    assert "CREATE TABLE" in sql
+```
+
+---
+
+## 3. Project Structure
+
+```
+ddlglot/
+├── pyproject.toml
+├── src/ddlglot/
+│   ├── __init__.py
+│   ├── builder.py          # Core fluent builder
+│   ├── properties.py       # Property helpers
+│   └── variants/
+│       ├── __init__.py
+│       └── spark_delta.py  # Spark + Delta preset
+└── tests/
+    ├── test_core.py
+    └── test_spark_delta.py
+```
+
+---
+
+## 4. Key Libraries
+
+- **sqlglot**: AST and SQL generation (installed as dependency)
+- **pytest**: Testing framework
+- **ruff**: Linting and formatting
+- **mypy**: Static type checking
+
+---
+
+## 5. Dialect-Specific Notes
+
+- The builder is **dialect-agnostic** at the AST level
+- Dialect-specific generation happens at `.sql(dialect=...)` call
+- Supported dialects: `postgres`, `sqlite`, `duckdb`, `spark`, `databricks`, etc.
+- SQLGlot's `Generator` handles dialect-specific syntax (e.g., `PARTITIONED BY` placement)
+
+---
+
+## 6. Common Tasks
+
+### Adding a New Dialect Preset
+
+1. Create `src/ddlglot/variants/<dialect>.py`
+2. Extend `CreateBuilder` following the pattern in `spark_delta.py`
+3. Export factory function `<dialect>_builder()`
+4. Add tests in `tests/test_<dialect>.py`
+
+### Adding New DDL Properties
+
+1. Add method to `CreateBuilder` (e.g., `.tblproperties()`)
+2. Implement property building in `_build_properties()`
+3. Use appropriate SQLGlot expression type (e.g., `exp.Properties`, `exp.Property`)
+4. Add tests covering the new property
+
+---
+
+## 7. Git Workflow
+
+- Use Conventional Commits: `feat(scope): description`, `fix(scope): description`
+- Run `pytest` and `ruff check .` before committing
+- Never commit directly to `main`; use feature branches

ddlglot-26.3.0/CHANGELOG.md

@@ -0,0 +1,32 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [26.3.0] - 2026-03-20
+
+### Added
+
+- Core builder with fluent API for DDL generation
+- Support for multiple SQL dialects:
+  - Spark+Delta Lake with CDF support
+  - Apache Hive with SERDE/ROW FORMAT
+  - PostgreSQL
+  - DuckDB
+  - BigQuery
+- Plugin registry system for custom variants
+- Dialect-specific validation
+- Comprehensive test suite (92 tests)
+- GitHub Actions CI/CD
+- Sphinx documentation
+- Pre-commit hooks
+
+### Features
+
+- `create()` factory function for generic DDL
+- `create_spark_delta()`, `create_hive()`, etc. for dialect-specific DDL
+- Fluent method chaining for all DDL operations
+- Type hints and validation
+- SQLGlot-powered AST generation

ddlglot-26.3.0/PKG-INFO

@@ -0,0 +1,137 @@
+Metadata-Version: 2.4
+Name: ddlglot
+Version: 26.3.0
+Summary: Fluent DDL builder using SQLGlot AST
+Author-email: alexsyntonize <249129647+alexsyntonize@users.noreply.github.com>
+Requires-Python: >=3.13
+Requires-Dist: sqlglot>=25.0.0
+Provides-Extra: dev
+Requires-Dist: mypy>=1.8; extra == 'dev'
+Requires-Dist: pytest-cov>=4.0; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: ruff>=0.4.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# ddlglot
+
+**Fluent DDL builder API using SQLGlot's AST**
+
+[![CI](https://github.com/alexmarco/ddlglot/actions/workflows/ci.yml/badge.svg)](https://github.com/alexmarco/ddlglot/actions/workflows/ci.yml)
+[![PyPI version](https://img.shields.io/pypi/v/ddlglot.svg)](https://pypi.org/project/ddlglot/)
+[![Python versions](https://img.shields.io/pypi/pyversions/ddlglot.svg)](https://pypi.org/project/ddlglot/)
+
+## Features
+
+- **Fluent API**: Chain method calls to build DDL statements
+- **Multiple Dialects**: Support for Spark, Delta Lake, Hive, PostgreSQL, DuckDB, BigQuery
+- **Type Safe**: Full type hints and validation
+- **SQLGlot Powered**: Leverage SQLGlot's AST for SQL generation
+
+## Installation
+
+```bash
+pip install ddlglot
+```
+
+Or with uv:
+
+```bash
+uv add ddlglot
+```
+
+## Quick Start
+
+```python
+from ddlglot import create
+
+# Create a table
+sql = (
+    create("table")
+    .name("public.users")
+    .column("id", "INT", not_null=True)
+    .column("name", "VARCHAR(100)")
+    .sql(dialect="postgres")
+)
+# CREATE TABLE public.users (id INT NOT NULL, name VARCHAR(100))
+```
+
+## Dialect Variants
+
+### Spark+Delta
+
+```python
+from ddlglot import create_spark_delta
+
+sql = (
+    create_spark_delta()
+    .name("default.events")
+    .column("id", "INT")
+    .partitioned_by("event_date")
+    .enable_cdf(True)
+    .sql()
+)
+```
+
+### Hive
+
+```python
+from ddlglot import create_hive
+
+sql = (
+    create_hive()
+    .name("default.events")
+    .column("id", "INT")
+    .stored_as("PARQUET")
+    .sql()
+)
+```
+
+### BigQuery
+
+```python
+from ddlglot import create_bigquery
+
+sql = (
+    create_bigquery()
+    .name("project.dataset.events")
+    .column("id", "INT64")
+    .partitioned_by("event_date")
+    .cluster_by("user_id")
+    .sql()
+)
+```
+
+## Validation
+
+The library validates dialect-specific constraints:
+
+```python
+from ddlglot import create_duckdb
+from ddlglot.exceptions import UnsupportedFeatureError
+
+# DuckDB doesn't support partitioning
+try:
+    create_duckdb().name("test").partitioned_by("date").sql()
+except UnsupportedFeatureError as e:
+    print(f"Error: {e}")
+```
+
+## Development
+
+```bash
+# Install dependencies
+pip install -e ".[dev]"
+
+# Run tests
+pytest tests/
+
+# Lint
+ruff check src tests
+
+# Type check
+mypy src
+```
+
+## License
+
+MIT License