Laravel PostgreSQL Enhanced

https://github.com/tpetry/laravel-postgresql-enhanced
Admin
Laravel PostgreSQL Enhanced is a PHP package adding PostgreSQL features to Laravel: zero-downtime...
Tokens:64,417
Snippets:716
Trust Score:8.5
License:MIT
Update:4 months ago
Show doc for...
Tokens:
Raw
### Install Package with Composer

Source: https://github.com/tpetry/laravel-postgresql-enhanced/blob/master/README.md

Use this command to install the package. Ensure you are in your project's root directory.

```bash
composer require tpetry/laravel-postgresql-enhanced
```

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

### Zero-Downtime Migration Example

Source: https://github.com/tpetry/laravel-postgresql-enhanced/blob/master/README.md

Implement zero-downtime migrations by using the ZeroDowntimeMigration trait and setting specific timeout values.

```php
use Illuminate\Database\Migrations\Migration;
use Tpetry\PostgresqlEnhanced\Schema\Blueprint;
use Tpetry\PostgresqlEnhanced\Schema\Concerns\ZeroDowntimeMigration;
use Tpetry\PostgresqlEnhanced\Support\Facades\Schema;

class Test123 extends Migration
{
    use ZeroDowntimeMigration;

    /**
     * Run the migrations.
     */
    public function up(): void
    {
        Schema::table('user', function (Blueprint $table) {
            $table->string('name', 128)->change();
        });
    }

    /**
     * Reverse the migrations.
     */
    public function down(): void
    {
        Schema::table('user', function (Blueprint $table) {
            $table->string('name', 32)->change();
        });
    }
}
```

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

### Complete Zero Downtime Migration Example

Source: https://github.com/tpetry/laravel-postgresql-enhanced/blob/master/_autodocs/api-reference/migrations-advanced.md

A comprehensive example of a zero-downtime migration for time-series data. It includes creating a hypertable, defining a function for data rollup, and adding a unique index with a condition.

```php
<?php

use Illuminate\Database\Migrations\Migration;
use Tpetry\PostgresqlEnhanced\Schema\Blueprint;
use Tpetry\PostgresqlEnhanced\Schema\Concerns\ZeroDowntimeMigration;
use Tpetry\PostgresqlEnhanced\Support\Facades\Schema;

return new class extends Migration {
    use ZeroDowntimeMigration;

    public function up(): void
    {
        // Create hypertable for time-series data
        Schema::createExtensionIfNotExists('timescaledb');

        Schema::create('metrics', function (Blueprint $table) {
            $table->id();
            $table->string('metric_name');
            $table->float('value');
            $table->timestampTz('recorded_at');

            $table->index(['metric_name', 'recorded_at']);
            
            // Unlogged: OK to lose recent metrics
            $table->unlogged();
            
            // Optimize for time-series writes
            $table->with(['fillfactor' => 100]);
        });

        // Create function for rollup
        Schema::createFunctionOrReplace(
            'rollup_metrics',
            [],
            'void',
            'plpgsql',
            'BEGIN DELETE FROM metrics WHERE recorded_at < now() - interval \'7 days\'; END;'
        );

        // Create unique index excluding soft-deleted rows
        Schema::table('metrics', function (Blueprint $table) {
            $table->uniqueIndex(['metric_name'])
                ->where('deleted_at IS NULL')
                ->concurrently();
        });
    }

    public function down(): void
    {
        Schema::dropFunctionIfExists('rollup_metrics');
        Schema::dropIfExists('metrics');
    }
};
```

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

### PHP Method Signature Example

Source: https://github.com/tpetry/laravel-postgresql-enhanced/blob/master/_autodocs/README.md

Demonstrates the standard format for method signatures, including type hints for parameters and return types.

```php
public function methodName(
    Type1 $param1,
    Type2 $param2 = 'default'
): ReturnType
```

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

### ZeroDowntimeMigration Example

Source: https://github.com/tpetry/laravel-postgresql-enhanced/blob/master/_autodocs/api-reference/migrations-advanced.md

This example demonstrates how to use the ZeroDowntimeMigration trait to modify a column in the 'users' table. If the migration exceeds the defined timeout, it will automatically roll back.

```php
use Illuminate\Database\Migrations\Migration;
use Tpetry\PostgresqlEnhanced\Schema\Blueprint;
use Tpetry\PostgresqlEnhanced\Schema\Concerns\ZeroDowntimeMigration;
use Tpetry\PostgresqlEnhanced\Support\Facades\Schema;

class AlterUserTable extends Migration
{
    use ZeroDowntimeMigration;

    public function up(): void
    {
        Schema::table('users', function (Blueprint $table) {
            $table->string('name', 128)->change();
        });
    }

    public function down(): void
    {
        Schema::table('users', function (Blueprint $table) {
            $table->string('name', 32)->change();
        });
    }
}
```

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

### Creating an Optimized Table for Write-Heavy Workloads

Source: https://github.com/tpetry/laravel-postgresql-enhanced/blob/master/_autodocs/api-reference/migrations-advanced.md

This example shows how to create a table with specific storage parameters optimized for write-heavy workloads, using `fillfactor` and `autovacuum_analyze_scale_factor`.

```php
Schema::create('events', function (Blueprint $table) {
    $table->id();
    $table->text('event_data');
    $table->timestamps();
    
    // Optimize for write-heavy workload
    $table->with([
        'fillfactor' => 90, // Leave 10% free space for updates
        'autovacuum_analyze_scale_factor' => 0.02, // More frequent analysis
    ]);
});
```

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

### createExtension

Source: https://github.com/tpetry/laravel-postgresql-enhanced/blob/master/_autodocs/api-reference/schema-builder.md

Creates a PostgreSQL extension. You can specify the schema to install the extension in. Throws an exception if the extension doesn't exist or already exists.

```APIDOC
## createExtension

### Description
Creates a PostgreSQL extension.

### Method
POST

### Endpoint
/schema/extension

### Parameters
#### Query Parameters
- **name** (string) - Required - Extension name (e.g., 'uuid-ossp', 'hstore')
- **schema** (string) - Optional - Schema to install extension in

### Response
#### Success Response (200)
- **message** (string) - Success message

### Error Handling
- **400** - If extension doesn't exist or already exists.
```

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

### Example: Logging User Updates with Conditional Trigger

Source: https://github.com/tpetry/laravel-postgresql-enhanced/blob/master/_autodocs/api-reference/migrations-advanced.md

This example demonstrates creating a trigger to log changes to the 'users' table. It fires after each update for every row and includes a condition to only log if any column value has changed.

```php
Schema::create('audit_log', function (Blueprint $table) {
    $table->id();
    $table->timestamp('action_at');
    $table->string('action_type');
    $table->json('old_values');
    $table->json('new_values');
});

Schema::table('users', function (Blueprint $table) {
    // Log all updates
    $table->trigger(
        'log_user_changes',
        'log_user_audit()',
        'AFTER UPDATE'
    )
    ->forEachRow()
    ->whenCondition(fn($q) => $q->whereRaw('(NEW).* IS DISTINCT FROM (OLD).*'));
});
```

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

### Create Table with Domain Columns

Source: https://github.com/tpetry/laravel-postgresql-enhanced/blob/master/_autodocs/api-reference/migrations-advanced.md

This example demonstrates creating a domain first and then using it to define columns in a new table. The domain `price` is defined with constraints and used for `base_price` and `sale_price` columns.

```php
// Create domain first
Schema::createDomain('price', 'numeric(9,2)', 'VALUE >= 0');

Schema::create('products', function (Blueprint $table) {
    $table->id();
    $table->string('name');
    $table->domain('base_price', 'price');
    $table->domain('sale_price', 'price')->nullable();
});
```

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

### Creating an Unlogged Table for Session Cache

Source: https://github.com/tpetry/laravel-postgresql-enhanced/blob/master/_autodocs/api-reference/migrations-advanced.md

This example demonstrates creating an unlogged table suitable for session cache data, where data loss on crash is acceptable.

```php
Schema::create('session_cache', function (Blueprint $table) {
    $table->id();
    $table->string('session_id')->unique();
    $table->json('data');
    $table->timestamp('expires_at');
    
    $table->unlogged(); // Not critical if lost
});
```

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

### Get Query Plan

Source: https://github.com/tpetry/laravel-postgresql-enhanced/blob/master/README.md

Retrieve the query plan for a given database query. This basic usage activates default explain options.

```php
DB::table('migrations')->where('batch', 1)->explain()->dd();
```

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

### Get Query Execution Plan

Source: https://github.com/tpetry/laravel-postgresql-enhanced/blob/master/_autodocs/api-reference/query-builder-advanced.md

Retrieves the query execution plan using PostgreSQL's EXPLAIN command. Can optionally execute the query to include actual timing and buffer statistics.

```php
// Get query plan
$plan = DB::table('users')
    ->where('email', 'like', '%example.com%')
    ->explain();

foreach ($plan as $line) {
    echo $line;
}

// Get query plan with execution metrics
$analysis = DB::table('orders')
    ->where('created_at', '>=', now()->subMonth())
    ->groupBy('user_id')
    ->orderBy('total', 'desc')
    ->explain(analyze: true);

// Output includes actual row counts, execution time, buffer statistics
```

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

### Get Query Plan with Analyze

Source: https://github.com/tpetry/laravel-postgresql-enhanced/blob/master/README.md

Retrieve the query plan with runtime analysis, including per-operation timing and buffer statistics. This requires setting 'analyze' to true.

```php
DB::table('migrations')->where('batch', 1)->explain(analyze:true)->dd();
```

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

### Example of OR Variants for Where Clauses

Source: https://github.com/tpetry/laravel-postgresql-enhanced/blob/master/_autodocs/api-reference/query-builder-where-clauses.md

Demonstrates the usage of OR variants for various where clause methods, allowing for combined conditions using OR logic. This example shows OR conditions for status, any value in a role array, and a symmetric date range.

```php
User::where('status', 'active')
    ->orWhereAnyValue('role', '=', ['admin', 'moderator'])
    ->orWhereBetweenSymmetric('created_at', [now()->subMonth(), now()])
    ->get();
```

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

### Cache Database Query Results with Redis

Source: https://github.com/tpetry/laravel-postgresql-enhanced/blob/master/_autodocs/configuration.md

Demonstrates using Redis for caching query results to improve performance, with a specific example for full-text search.

```php
$results = Cache::remember('key', now()->addHour(), function () {
    return DB::table('users')->whereFullText(['name'], 'term')->get();
});
```

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

### Enabling and Using Vector Type in Tests

Source: https://github.com/tpetry/laravel-postgresql-enhanced/blob/master/_autodocs/configuration.md

In testing environments, all PostgreSQL types are automatically registered. This example shows how to create a PostgreSQL extension and add a vector column to a table.

```php
// In tests, all PostgreSQL types are available
Schema::createExtensionIfNotExists('vector');
Schema::table('documents', function (Blueprint $table) {
    $table->vector('embedding'); // Works in tests
});
```

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

### Create PostgreSQL Extension

Source: https://github.com/tpetry/laravel-postgresql-enhanced/blob/master/_autodocs/api-reference/schema-builder.md

Use this method to create a PostgreSQL extension. Specify the extension name and optionally the schema where it should be installed. Throws an exception if the extension does not exist or already exists.

```php
use Tpetry\PostgresqlEnhanced\Support\Facades\Schema;

Schema::createExtension('uuid-ossp');
Schema::createExtension('hstore', schema: 'public');
Schema::createExtensionIfNotExists('pgcrypto');
```

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

### Create Posts Table with Non-Enforced Foreign Key

Source: https://github.com/tpetry/laravel-postgresql-enhanced/blob/master/_autodocs/api-reference/migrations-advanced.md

An example demonstrating the creation of a 'posts' table with a non-enforced foreign key to the 'users' table. The enforcement behavior is conditionally applied based on the production environment.

```php
Schema::create('posts', function (Blueprint $table) {
    $table->id();
    $table->foreignId('user_id')
        ->constrained('users')
        // Production: non-enforced (faster), dev: enforced (catch bugs)
        ->notEnforced(app()->isProduction());
    $table->string('title');
});
```

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

### Create Function Returning Table

Source: https://github.com/tpetry/laravel-postgresql-enhanced/blob/master/README.md

Define a function that returns a table by specifying the columns as the return type. This example shows searching users by a pattern.

```php
Schema::createFunction('search_user', ['pattern' => 'text'], ['id' => 'int', 'email' => 'text'], 'plpgsql', "
  BEGIN
    RETURN QUERY select user_id, contactemail from users where name ilike '%' || pattern || '%';
  END;
");
```

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

### Complete Model Example with PostgreSQL Enhanced Features

Source: https://github.com/tpetry/laravel-postgresql-enhanced/blob/master/_autodocs/api-reference/eloquent-features.md

Define an Eloquent model using custom concerns and casts for PostgreSQL specific data types like VectorArray. Demonstrates model creation, vector similarity search, bulk insert with returning IDs, and lazy loading with transactions.

```php
<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Model;
use Tpetry\PostgresqlEnhanced\Eloquent\Casts\VectorArray;
use Tpetry\PostgresqlEnhanced\Eloquent\Concerns\AutomaticDateFormat;
use Tpetry\PostgresqlEnhanced\Eloquent\Concerns\RefreshDataOnSave;

class Document extends Model
{
    use AutomaticDateFormat;
    use RefreshDataOnSave;

    protected $fillable = [
        'title',
        'content',
        'embedding',
        'category_id',
    ];

    protected $casts = [
        'embedding' => VectorArray::class,
        'created_at' => 'datetime',
        'updated_at' => 'datetime',
    ];
}

// Usage
$doc = Document::create([
    'title' => 'Advanced PostgreSQL',
    'content' => 'Learn PostgreSQL features...',
    'embedding' => $openaiEmbedding, // 1536 dimensions
]);

// Search similar documents
$similar = Document::orderByVectorSimilarity('embedding', $queryEmbedding)
    ->limit(5)
    ->get();

// Bulk insert with auto-generated IDs
$docs = Document::query()->insertReturning($docArray);

// Lazy load large collections
DB::transaction(function () {
    Document::lazyByCursor()->each(function (Document $doc) {
        // Process
    });
});

```

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

### PHPStan Configuration for Laravel PostgreSQL Enhanced

Source: https://github.com/tpetry/laravel-postgresql-enhanced/blob/master/README.md

Manually add the PHPStan extension path to your phpstan.neon configuration file if the extension installer is not used.

```yaml
includes:
    - ./vendor/nunomaduro/larastan/extension.neon
    - ./vendor/tpetry/laravel-postgresql-enhanced/phpstan-extension.neon
```

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

### explain

Source: https://github.com/tpetry/laravel-postgresql-enhanced/blob/master/_autodocs/api-reference/query-builder-advanced.md

Retrieves the query execution plan using PostgreSQL's EXPLAIN command. Optionally executes the query to include actual timing and buffer information.

```APIDOC
## explain

### Description
Retrieves the query execution plan with PostgreSQL EXPLAIN.

### Method
Not specified (likely part of a fluent builder pattern)

### Endpoint
Not applicable (SDK method)

### Parameters
#### Path Parameters
None

#### Query Parameters
- **analyze** (bool) - Optional - Execute query and include actual timing/buffers

#### Request Body
None

### Request Example
```php
// Get query plan
$plan = DB::table('users')
    ->where('email', 'like', '%example.com%')
    ->explain();

// Get query plan with execution metrics
$analysis = DB::table('orders')
    ->where('created_at', '>=', now()->subMonth())
    ->groupBy('user_id')
    ->orderBy('total', 'desc')
    ->explain(analyze: true);
```

### Response
#### Success Response
- **Collection** - Query plan as formatted text

#### Response Example
```
// Output includes query plan lines, or actual row counts, execution time, buffer statistics when analyze is true
```
```

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

### Specify Index Storage Parameters (GIN)

Source: https://github.com/tpetry/laravel-postgresql-enhanced/blob/master/README.md

Configure storage parameters for indexes, particularly useful for GIN indexes to optimize performance. Use the `with` method to pass these parameters.

```php
use Tpetry\PostgresqlEnhanced\Schema\Blueprint;
use Tpetry\PostgresqlEnhanced\Support\Facades\Schema;

Schema::table('bookmarks', function(Blueprint $table) {
    $table->index('data')->algorithm('gin')->with(['fastupdate' => false]);
});
```

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

### RETURNING Clause for Bulk Operations

Source: https://github.com/tpetry/laravel-postgresql-enhanced/blob/master/_autodocs/README.md

Utilize the RETURNING clause to get inserted rows back from bulk insert operations.

```php
// RETURNING clause for bulk operations
$users = DB::table('users')->insertReturning([...], returning: ['id', 'email']);
```

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

### Import Facade

Source: https://github.com/tpetry/laravel-postgresql-enhanced/blob/master/_autodocs/README.md

Import the necessary facades for using the package's schema builder and blueprint.

```php
use Tpetry\PostgresqlEnhanced\Support\Facades\Schema;
use Tpetry\PostgresqlEnhanced\Schema\Blueprint;
```

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

### Configure Full-Text Search Indexes

Source: https://github.com/tpetry/laravel-postgresql-enhanced/blob/master/README.md

Create full-text search indexes with specified languages and column weights for ranking. Use the `fullText` method and chain `language` and `weight` methods to customize.

```php
use Tpetry\PostgresqlEnhanced\Schema\Blueprint;
use Tpetry\PostgresqlEnhanced\Support\Facades\Schema;

Schema::table('book', function (Blueprint $table) {
    $table->fullText(['title', 'description'])
        ->language('spanish')
        ->weight(['A', 'B']);
});
```

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

### Configure PostgreSQL Connection

Source: https://github.com/tpetry/laravel-postgresql-enhanced/blob/master/_autodocs/configuration.md

Set up your PostgreSQL connection details in the `config/database.php` file. This includes host, port, database name, username, password, character set, and schema.

```php
'pgsql' => [
    'driver' => 'pgsql',
    'url' => env('DATABASE_URL'),
    'host' => env('DB_HOST', '127.0.0.1'),
    'port' => env('DB_PORT', '5432'),
    'database' => env('DB_DATABASE', 'laravel'),
    'username' => env('DB_USERNAME', 'postgres'),
    'password' => env('DB_PASSWORD', ''),
    'charset' => 'utf8',
    'prefix' => '',
    'prefix_indexes' => true,
    'schema' => 'public',
    'sslmode' => 'prefer',
],
```

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

### Define Tsvector Columns for Full-Text Search

Source: https://github.com/tpetry/laravel-postgresql-enhanced/blob/master/_autodocs/api-reference/blueprint-column-types.md

Use `tsvector` to store precomputed full-text search data. This example shows storing it as a generated column.

```php
Schema::create('articles', function (Blueprint $table) {
    $table->id();
    $table->string('title');
    $table->text('content');
    $table->tsvector('search_vector')->storedAs("to_tsvector('english', title || ' ' || content)");
});

// Use with full-text search
Article::whereFullText(['search_vector'], 'PostgreSQL')->get();
```

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

### Create TimescaleDB Hypertable and Policies

Source: https://github.com/tpetry/laravel-postgresql-enhanced/blob/master/README.md

This snippet demonstrates creating a 'visits' hypertable with specified time intervals, enabling columnstore, and configuring retention and chunk skipping policies. Ensure indexes are created manually as they are not automatic.

```php
use Illuminate\Database\Migrations\Migration;
use Tpetry\PostgresqlEnhanced\Schema\Timescale\Actions\CreateColumnstorePolicy;
use Tpetry\PostgresqlEnhanced\Schema\Timescale\Actions\CreateHypertable;
use Tpetry\PostgresqlEnhanced\Schema\Timescale\Actions\CreateRefreshPolicy;
use Tpetry\PostgresqlEnhanced\Schema\Timescale\Actions\CreateRetentionPolicy;
use Tpetry\PostgresqlEnhanced\Schema\Timescale\Actions\EnableChunkSkipping;
use Tpetry\PostgresqlEnhanced\Schema\Timescale\Actions\EnableColumnstore;
use Tpetry\PostgresqlEnhanced\Schema\CaggBlueprint;
use Tpetry\PostgresqlEnhanced\Support\Facades\Schema;
use Tpetry\PostgresqlEnhanced\Schema\Blueprint;

return new class extends Migration
{
    public function up(): void
    {
        Schema::createExtensionIfNotExists('timescaledb');

        Schema::create('visits', function (Blueprint $table) {
            $table->identity();
            $table->bigInteger('website_id');
            $table->text('url');
            $table->float('duration');
            $table->timestampTz('created_at');

            $table->primary(['id', 'created_at']);
            $table->index(['website_id', 'created_at']);

            $table->timescale(
                new CreateHypertable('created_at', '1 day'),
                new EnableColumnstore(segmentBy: 'website_id'),
                new CreateColumnstorePolicy('3 days'),
                new CreateRetentionPolicy('1 year'),
                new EnableChunkSkipping('id'),
            );
        });

        Schema::continuousAggregate('visits_agg', function(CaggBlueprint $table) {
            $table->as $(
                "SELECT\n                    time_bucket('1 hour', created_at) AS bucket,\n                    website_id,\n                    url,\n                    SUM(duration) AS duration\n                FROM visits\n                GROUP BY bucket, website_id, url"
            );
            $table->realtime();
            $table->index(['website_id','url']);

            $table->timescale(
                new CreateRefreshPolicy('5 minutes', '1 days', '2 hours'),
                new EnableColumnstore(),
                new CreateColumnstorePolicy('2 days'),
            );
        });
    }
};

```

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

### Create Full-Text Indexes

Source: https://github.com/tpetry/laravel-postgresql-enhanced/blob/master/_autodocs/api-reference/blueprint-indexes.md

Implement full-text search indexes on multiple columns, specifying the language and weighting for each column.

```php
$table->fullText(['title', 'description'])
    ->language('english')
    ->weight(['A', 'B']);
```

```php
Schema::table('articles', function (Blueprint $table) {
    $table->id();
    $table->string('title');
    $table->text('description');
    $table->text('content');
    
    // Full-text index with weighted columns
    $table->fullText(['title', 'description', 'content'])
        ->language('english')
        ->weight(['A', 'A', 'B']);
});

// Query with full-text search
Article::whereFullText(['title', 'description', 'content'], 'PostgreSQL')->get();
```

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

### Specify Index With Options

Source: https://github.com/tpetry/laravel-postgresql-enhanced/blob/master/_autodocs/QUICK_REFERENCE.md

Use `with` to provide additional key-value options for the index.

```php
->with(['key' => 'value'])
```

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

### upsertReturning

Source: https://github.com/tpetry/laravel-postgresql-enhanced/blob/master/_autodocs/api-reference/query-builder-returning.md

Performs an upsert (insert or update on conflict) operation and returns the affected rows. This is useful for synchronizing data and immediately getting the state of the updated records.

```APIDOC
## upsertReturning

### Description
Performs an upsert (insert or update on conflict) operation and returns the affected rows. This is useful for synchronizing data and immediately getting the state of the updated records.

### Method
Not applicable (PHP method)

### Endpoint
Not applicable (PHP method)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
* **$values** (array) - Required - Records to upsert
* **$uniqueBy** (array|string) - Required - Column(s) for conflict detection
* **$update** (array|null) - Optional - Columns to update on conflict
* **$returning** (array) - Optional - Columns to return (defaults to ['*'])

### Request Example
```php
DB::table("subscriptions")->upsertReturning(
    [
        ['user_id' => 1, 'plan' => 'premium', 'expires_at' => now()->addYear()],
        ['user_id' => 2, 'plan' => 'basic', 'expires_at' => now()->addMonth()],
    ],
    uniqueBy: 'user_id',
    update: ['plan', 'expires_at'],
    returning: ['user_id', 'plan', 'expires_at']
);
```

### Response
#### Success Response
* **Collection<int, object>** - A collection of the affected row objects.

#### Response Example
```php
// Example of iterating through results
$results->each(function ($row) {
    echo "Subscription for user {$row->user_id}: {$row->plan}";
});
```
```

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

### Apply Index Include Columns

Source: https://github.com/tpetry/laravel-postgresql-enhanced/blob/master/_autodocs/QUICK_REFERENCE.md

Use `include` to specify additional columns to be included in the index.

```php
->include(['col1', 'col2'])
```

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

### Query Builder: Explain Query Plan

Source: https://github.com/tpetry/laravel-postgresql-enhanced/blob/master/_autodocs/QUICK_REFERENCE.md

Generate the query plan for a given query, optionally with `ANALYZE` to execute the query and show actual run times. Useful for performance tuning.

```php
explain($analyze = false)
```

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

### Identity Column Type for Auto-Incrementing IDs

Source: https://github.com/tpetry/laravel-postgresql-enhanced/blob/master/_autodocs/api-reference/blueprint-column-types.md

Implements PostgreSQL's standard auto-incrementing identity column. Allows customization of start value and increment, and can enforce 'always' identity.

```php
public function identity(
    bool $always = false,
    string $start = '1',
    string $increment = '1'
): ColumnDefinition
```

```php
Schema::create('users', function (Blueprint $table) {
    // Standard identity (can be overridden)
    $table->identity()->primary();
    
    // Always identity (cannot be overridden by applications)
    $table->identity(always: true)->primary();
    
    // Custom start value
    $table->identity(start: '1000')->primary();
});
```

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

### Control Data Exposure with insertReturning

Source: https://github.com/tpetry/laravel-postgresql-enhanced/blob/master/_autodocs/configuration.md

Shows how to use the insertReturning method and specify which columns to return, highlighting security considerations for sensitive data.

```php
// Returns email addresses
$users = DB::table('users')->insertReturning($data, returning: ['id', 'email']);

// More restrictive
$users = DB::table('users')->insertReturning($data, returning: ['id']);
```

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

### with

Source: https://github.com/tpetry/laravel-postgresql-enhanced/blob/master/_autodocs/api-reference/blueprint-indexes.md

Sets storage parameters for an index, such as 'fastupdate' for GIN indexes, to optimize for specific workloads (e.g., high-write or low-write scenarios).

```APIDOC
## with

### Description
Sets index storage parameters.

### GIN Parameters
| Parameter | Type | Description |
|-----------|------|-------------|
| fastupdate | bool | Faster updates, slower searches when true |
| gin_pending_list_limit | int | Memory for pending list in KB |

### Example
```php
Schema::table('bookmarks', function (Blueprint $table) {
    // High-write workload: optimize for searches
    $table->index('tags')->algorithm('gin')->with(['fastupdate' => false]);
    
    // Low-write workload: optimize for inserts
    $table->index('data')->algorithm('gin')->with(['fastupdate' => true]);
});
```
```

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

### Long Running Migration with Custom Timeout

Source: https://github.com/tpetry/laravel-postgresql-enhanced/blob/master/_autodocs/api-reference/migrations-advanced.md

This example shows a long-running migration with a custom timeout of 10 seconds. If the schema modification on 'large_table' exceeds this duration, the migration will be automatically rolled back.

```php
class LongRunningMigration extends Migration
{
    use ZeroDowntimeMigration;

    // Allow 10 seconds for this migration
    private float $timeout = 10.0;

    public function up(): void
    {
        Schema::table('large_table', function (Blueprint $table) {
            // Time-consuming migration
            $table->string('new_column')->default('')->change();
        });
    }
}
```

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

### Recursive Common Table Expression (CTE)

Source: https://github.com/tpetry/laravel-postgresql-enhanced/blob/master/_autodocs/QUICK_REFERENCE.md

Constructs a hierarchical data structure (like a category tree) using a recursive CTE. It starts with root categories and iteratively joins to find sub-categories.

```php
$hierarchy = DB::table('categories')
    ->withExpression('tree', 
        DB::table('categories')
            ->whereNull('parent_id')
            ->unionAll(DB::table('categories')
                ->joinRaw('tree ON categories.parent_id = tree.id'))
        , ['recursive' => true, 'cycle' => 'id SET is_cycle']
    )
    ->from('tree')
    ->get();
```

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

### Define Hstore Columns

Source: https://github.com/tpetry/laravel-postgresql-enhanced/blob/master/_autodocs/api-reference/blueprint-column-types.md

Use `hstore` for key-value pair storage. Requires the `hstore` extension. Note: JSONB is recommended for new applications.

```php
Schema::createExtensionIfNotExists('hstore');

Schema::create('metadata', function (Blueprint $table) {
    $table->id();
    $table->hstore('attributes');
});
```

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

### Create a Database View

Source: https://github.com/tpetry/laravel-postgresql-enhanced/blob/master/_autodocs/api-reference/schema-builder.md

Use `createView` to define a new database view. You can provide the query as a string or a query builder instance. Custom column names can also be specified.

```php
use Illuminate\Support\Facades\DB;
use Tpetry\PostgresqlEnhanced\Support\Facades\Schema;

// String query
Schema::createView('users_with_2fa', 'SELECT * FROM users WHERE two_factor_secret IS NOT NULL');

// Query builder
Schema::createView(
    'active_subscriptions',
    DB::table('subscriptions')->whereNull('cancelled_at')
);

// Custom column names
Schema::createView(
    'user_summary',
    DB::table('users')->select('id', 'email'),
    columns: ['user_id', 'user_email']
);
```

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

### Create Simple and Replaceable Views

Source: https://github.com/tpetry/laravel-postgresql-enhanced/blob/master/README.md

Use `createView` for new views or `createViewOrReplace` to update existing ones. The view definition can be a raw SQL string or a query builder instance.

```php
use Illuminate\Support\Facades\DB;
use Tpetry\PostgresqlEnhanced\Support\Facades\Schema;

Schema::createView('users_with_2fa', 'SELECT * FROM users WHERE two_factor_secret IS NOT NULL');
Schema::createViewOrReplace('users_without_2fa', DB::table('users')->whereNull('two_factor_secret'));
```

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

### Create Full-Text Index

Source: https://github.com/tpetry/laravel-postgresql-enhanced/blob/master/_autodocs/QUICK_REFERENCE.md

Use `fullText` to create a full-text index on specified columns.

```php
$table->fullText($columns)
```

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

### Set Table Storage Parameters

Source: https://github.com/tpetry/laravel-postgresql-enhanced/blob/master/README.md

Fine-tune table performance by setting storage parameters like 'fillfactor' or 'autovacuum_analyze_scale_factor'. Use the 'with' method on the table blueprint, passing an associative array of parameters.

```php
use Tpetry\PostgresqlEnhanced\Schema\Blueprint;
use Tpetry\PostgresqlEnhanced\Support\Facades\Schema;

Schema::table('sessions', function (Blueprint $table): void {
    $table->with([
        // Tune statistics generation for tables with millions of records
        'autovacuum_analyze_scale_factor' => 0.02,
        // Tune table for frequent UPDATE statements
        'fillfactor' => 90,
    ]);
});
```

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

### Setting Table Storage Parameters

Source: https://github.com/tpetry/laravel-postgresql-enhanced/blob/master/_autodocs/api-reference/migrations-advanced.md

The `with()` method allows setting PostgreSQL storage parameters like `fillfactor` and `autovacuum_analyze_scale_factor` for table optimization.

```php
Schema::table('users', function (Blueprint $table) {
    $table->with([
        'fillfactor' => 90,
        'autovacuum_analyze_scale_factor' => 0.02,
    ]);
});
```

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

### Using InsertReturning within a Transaction

Source: https://github.com/tpetry/laravel-postgresql-enhanced/blob/master/_autodocs/api-reference/query-builder-returning.md

Demonstrates how to insert records using `insertReturning` and process them immediately within a database transaction. This ensures atomicity for the insert and subsequent processing.

```php
DB::transaction(function () {
    $inserted = DB::table('orders')->insertReturning([...]);
    
    foreach ($inserted as $order) {
        // Process each inserted order immediately
        Queue::push(new ProcessOrder($order->id));
    }
});
```

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

### Configure PostgreSQL Connection Pooling

Source: https://github.com/tpetry/laravel-postgresql-enhanced/blob/master/_autodocs/configuration.md

Sets parameters in postgresql.conf to optimize connection handling for application servers.

```ini
# postgresql.conf
max_connections = 200
shared_buffers = 256MB
```

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

### Create PostgreSQL Extension

Source: https://github.com/tpetry/laravel-postgresql-enhanced/blob/master/README.md

Use the Schema facade to create a PostgreSQL extension. The `createExtensionIfNotExists` method prevents errors if the extension already exists.

```php
use Tpetry\PostgresqlEnhanced\Support\Facades\Schema;

Schema::createExtension('tablefunc');
Schema::createExtensionIfNotExists('tablefunc');
```

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

### Full-Text Search Index with Weights Migration

Source: https://github.com/tpetry/laravel-postgresql-enhanced/blob/master/_autodocs/README.md

Create a full-text search index on multiple columns with specified weights for relevance.

```php
// Full-text search index with weights
Schema::table('articles', function (Blueprint $table) {
    $table->fullText(['title', 'content'])
        ->language('english')
        ->weight(['A', 'B']);
});
```

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

### Create and Drop PostgreSQL Extensions

Source: https://github.com/tpetry/laravel-postgresql-enhanced/blob/master/_autodocs/QUICK_REFERENCE.md

Methods for creating and dropping PostgreSQL extensions. Use `createExtensionIfNotExists` to avoid errors if the extension already exists. `dropExtension` can take multiple extension names.

```php
Schema::createExtension('extension_name', $schema = null)
Schema::createExtensionIfNotExists('extension_name', $schema = null)
Schema::dropExtension(...$names)
Schema::dropExtensionIfExists(...$names)
```

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

### Create Standard Index

Source: https://github.com/tpetry/laravel-postgresql-enhanced/blob/master/_autodocs/QUICK_REFERENCE.md

Use `index` to create a non-unique index on one or more columns.

```php
$table->index($columns, $name = null)
```

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

### Apply Concurrent Index Creation

Source: https://github.com/tpetry/laravel-postgresql-enhanced/blob/master/_autodocs/QUICK_REFERENCE.md

Use `concurrently` to create the index without locking the table.

```php
->concurrently()
```

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

### Create a Table Trigger

Source: https://github.com/tpetry/laravel-postgresql-enhanced/blob/master/README.md

Use the `trigger` method on the Blueprint to add a trigger to a table. Specify the trigger name, the function to call, and the action that fires it.

```php
use Tpetry\PostgresqlEnhanced\Schema\Blueprint;
use Tpetry\PostgresqlEnhanced\Support\Facades\Schema;

Schema::table('projects', function (Blueprint $table): void {
    $table->trigger('rollup_quota', 'update_quota_by_projects()', 'AFTER INSERT OR DELETE');
});
```

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

### Extensions

Source: https://github.com/tpetry/laravel-postgresql-enhanced/blob/master/_autodocs/INDEX.md

Methods for creating and dropping PostgreSQL extensions.

```APIDOC
## Extensions

### Description
Methods for managing PostgreSQL extensions.

### Methods
- `createExtension(name, schema)`
- `createExtensionIfNotExists(name, schema)`
- `dropExtension(...names)`
- `dropExtensionIfExists(...names)`
```

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

### Define Table Options

Source: https://github.com/tpetry/laravel-postgresql-enhanced/blob/master/_autodocs/QUICK_REFERENCE.md

Mark tables as unlogged or configure storage parameters like fillfactor and autovacuum settings.

```php
$table->unlogged()
```

```php
$table->unlogged(false)
```

```php
$table->with([
    'fillfactor' => 90,
    'autovacuum_analyze_scale_factor' => 0.02,
])
```

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

### Create Temporal Indexes for Addresses and Orders

Source: https://github.com/tpetry/laravel-postgresql-enhanced/blob/master/README.md

Defines temporal indexes for 'addresses' and 'orders' tables, enabling version control of data. Ensure the 'btree_gist' extension is created first.

```php
use Tpetry\PostgresqlEnhanced\Schema\Blueprint;
use Tpetry\PostgresqlEnhanced\Support\Facades\Schema;

Schema::createExtensionIfNotExists('btree_gist');
Schema::create('addresses', function (Blueprint $table) {
    $table->uuid('id');
    $table->timestampTzRange('valid');
    // ...

    $table->primary(['id', 'valid WITHOUT OVERLAPS']);
});
Schema::create('orders', function (Blueprint $table) {
    $table->uuid('id');
    $table->uuid('address_id');
    $table->text('reference_nr');
    $table->timestampTzRange('valid');
    // ...

    $table->primary(['id', 'valid WITHOUT OVERLAPS']);
    $table->unique(['reference_nr', 'valid WITHOUT OVERLAPS']);
    $table->foreign(['address_id', 'PERIOD valid'])->references(['id', 'PERIOD valid'])->on('addresses');
});

```

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

### Create Spatial Index

Source: https://github.com/tpetry/laravel-postgresql-enhanced/blob/master/_autodocs/QUICK_REFERENCE.md

Use `spatialIndex` to create a spatial index on specified columns.

```php
$table->spatialIndex($columns)
```

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

### Views

Source: https://github.com/tpetry/laravel-postgresql-enhanced/blob/master/_autodocs/INDEX.md

Methods for creating and dropping PostgreSQL views.

```APIDOC
## Views

### Description
Methods for creating, replacing, and dropping PostgreSQL views.

### Methods
- `createView(name, query, columns)`
- `createViewOrReplace(name, query, columns)`
- `createRecursiveView(name, query, columns)`
- `createRecursiveViewOrReplace(name, query, columns)`
- `dropView(...names)`
- `dropViewIfExists(...names)`
```

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

### Index Algorithms Type Constants

Source: https://github.com/tpetry/laravel-postgresql-enhanced/blob/master/_autodocs/types.md

Lists the supported index algorithms for PostgreSQL.

```php
'btree' | 'hash' | 'gin' | 'gist' | 'brin' | 'spgist'
```

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

### Specify Index Algorithm

Source: https://github.com/tpetry/laravel-postgresql-enhanced/blob/master/_autodocs/QUICK_REFERENCE.md

Use `algorithm` to specify the index algorithm (e.g., btree, hash).

```php
->algorithm('btree|hash|gin|gist|brin|spgist')
```

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

### PostgreSQL Environment Variables

Source: https://github.com/tpetry/laravel-postgresql-enhanced/blob/master/_autodocs/configuration.md

Common environment variables for configuring a PostgreSQL database connection, including connection details, SSL, and pooling settings.

```bash
# Database connection
DB_CONNECTION=pgsql
DB_HOST=127.0.0.1
DB_PORT=5432
DB_DATABASE=laravel
DB_USERNAME=postgres
DB_PASSWORD=secret

# SSL configuration
DB_SSLMODE=prefer

# Pool configuration
DB_POOL_MIN=2
DB_POOL_MAX=10
```

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

### algorithm

Source: https://github.com/tpetry/laravel-postgresql-enhanced/blob/master/_autodocs/api-reference/blueprint-indexes.md

Specifies the algorithm used for creating the index. Supported algorithms include 'btree', 'hash', 'gin', 'gist', 'brin', and 'spgist'.

```APIDOC
## algorithm

### Description
Specifies index algorithm.

### Values
`'btree'` (default), `'hash'`, `'gin'`, `'gist'`, `'brin'`, `'spgist'`

### Example
```php
Schema::table('documents', function (Blueprint $table) {
    // Full-text search index
    $table->index('content')->algorithm('gin');
    
    // JSON containment queries
    $table->index('metadata')->algorithm('gin');
    
    // Large range queries with low selectivity
    $table->index('created_at')->algorithm('brin');
});
```
```

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

### Any/All Value WHERE Clause Signatures

Source: https://github.com/tpetry/laravel-postgresql-enhanced/blob/master/README.md

Provides the method signatures for various Any/All value comparisons, including positive, negative, and OR variations.

```php
$query->whereAllValues($column, string $operator, iterable $values);
$query->whereNotAllValues($column, string $operator, iterable $values);
$query->orWhereAllValues($column, string $operator, iterable $values);
$query->orWhereNotAllValues($column, string $operator, iterable $values);
$query->whereAnyValue($column, string $operator, iterable $values);
$query->whereNotAnyValue($column, string $operator, iterable $values);
$query->orWhereAnyValue($column, string $operator, iterable $values);
$query->orWhereNotAnyValue($column, string $operator, iterable $values)
```

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

### Create and Drop PostgreSQL Views

Source: https://github.com/tpetry/laravel-postgresql-enhanced/blob/master/_autodocs/QUICK_REFERENCE.md

Methods for creating, replacing, and dropping standard PostgreSQL views. Supports recursive views and specifying column definitions. Use `dropView` for multiple view names.

```php
Schema::createView($name, $query, $columns = [])
Schema::createViewOrReplace($name, $query, $columns = [])
Schema::createRecursiveView($name, $query, $columns)
Schema::createRecursiveViewOrReplace($name, $query, $columns)
Schema::dropView(...$names)
Schema::dropViewIfExists(...$names)
```

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

### Create Recursive Views

Source: https://github.com/tpetry/laravel-postgresql-enhanced/blob/master/README.md

Use `createRecursiveView` and `createRecursiveViewOrReplace` for recursive views. You must provide the available columns as the last parameter.

```php
use Illuminate\Support\Facades\DB;
use Tpetry\PostgresqlEnhanced\Support\Facades\Schema;

// TODO simple example explaining the concept
Schema::createRecursiveView('viewname', 'SELECT id, col1, col2 FROM ....', ['id', 'col1', 'col2']);
Schema::createRecursiveViewOrReplace('viewname', 'SELECT id, col1, col2 FROM ....', ['id', 'col1', 'col2']);
```

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

### Skip Index Creation if Exists

Source: https://github.com/tpetry/laravel-postgresql-enhanced/blob/master/_autodocs/api-reference/blueprint-indexes.md

Use the ifNotExists method to prevent an error if the index already exists. This is useful for running migrations on production environments where indexes might have been created manually.

```php
$table->index('email')->ifNotExists();
```

```php
// Previously created index manually in production
$table->index(['status', 'created_at'])->ifNotExists();

// Migration safely runs without conflict
```

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

### createView

Source: https://github.com/tpetry/laravel-postgresql-enhanced/blob/master/_autodocs/api-reference/schema-builder.md

Creates a database view with a specified name, query, and optional custom column names.

```APIDOC
## createView

### Description
Creates a database view.

### Method
`createView(string $name, Builder|string $query, array $columns = [])`

### Parameters
#### Path Parameters
- **name** (string) - Required - View name
- **query** (Builder|string) - Required - Query definition or query builder instance
- **columns** (array) - Optional - Custom column names

### Request Example
```php
use Illuminate\Support\Facades\DB;
use Tpetry\PostgresqlEnhanced\Support\Facades\Schema;

// String query
Schema::createView('users_with_2fa', 'SELECT * FROM users WHERE two_factor_secret IS NOT NULL');

// Query builder
Schema::createView(
    'active_subscriptions',
    DB::table('subscriptions')->whereNull('cancelled_at')
);

// Custom column names
Schema::createView(
    'user_summary',
    DB::table('users')->select('id', 'email'),
    columns: ['user_id', 'user_email']
);
```
```

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

### Create Views with Custom Column Names

Source: https://github.com/tpetry/laravel-postgresql-enhanced/blob/master/README.md

Specify alternative names for view columns by providing an array of column names as the last parameter to `createView`.

```php
use Illuminate\Support\Facades\DB;
use Tpetry\PostgresqlEnhanced\Support\Facades\Schema;

Schema::createView('users_with_2fa', DB::table('users')->select('id')->whereNull('two_factor_secret'), ['user_id']);
```

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

### Create Database Function

Source: https://github.com/tpetry/laravel-postgresql-enhanced/blob/master/_autodocs/QUICK_REFERENCE.md

Defines how to create a custom database function using Schema::createFunction. Allows configuration of volatility, parallel execution, leakproofness, security, cost, and search path.

```php
Schema::createFunction($name, $params, $return, $language, $body, [
    'volatility' => 'immutable|stable|volatile',
    'parallel' => 'safe|restricted|unsafe',
    'leakproof' => true|false,
    'calledOnNull' => true|false,
    'security' => 'definer|invoker',
    'cost' => 100,
    'searchPath' => ['public', 'my_schema'],
])
```

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

### Create and Drop PostgreSQL Functions

Source: https://github.com/tpetry/laravel-postgresql-enhanced/blob/master/_autodocs/QUICK_REFERENCE.md

Methods for creating, replacing, and dropping PostgreSQL functions. Specify parameters, return type, language, body, and options for creation. Arguments can be specified for dropping functions.

```php
Schema::createFunction($name, $parameters, $return, $language, $body, $options = [])
Schema::createFunctionOrReplace($name, $parameters, $return, $language, $body, $options = [])
Schema::dropFunction($name, $arguments = null)
Schema::dropFunctionIfExists($name, $arguments = null)
```

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

### Set Index Storage Parameters

Source: https://github.com/tpetry/laravel-postgresql-enhanced/blob/master/_autodocs/api-reference/blueprint-indexes.md

Use the `with` modifier to set index storage parameters. For GIN indexes, parameters like `fastupdate` and `gin_pending_list_limit` can be specified.

```php
$table->index('data')->algorithm('gin')->with(['fastupdate' => false]);
```

```php
Schema::table('bookmarks', function (Blueprint $table) {
    // High-write workload: optimize for searches
    $table->index('tags')->algorithm('gin')->with(['fastupdate' => false]);
    
    // Low-write workload: optimize for inserts
    $table->index('data')->algorithm('gin')->with(['fastupdate' => true]);
});
```

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

### Set Column Compression with LZ4

Source: https://github.com/tpetry/laravel-postgresql-enhanced/blob/master/README.md

Specify 'lz4' compression for string columns to reduce TOAST data size. Ensure PostgreSQL version 14+ is used.

```php
use Tpetry\PostgresqlEnhanced\Schema\Blueprint;
use Tpetry\PostgresqlEnhanced\Support\Facades\Schema;

Schema::table('books', function (Blueprint $table): void {
    // @see https://www.postgresql.org/docs/current/storage-toast.html
    $table->string('summary')->compression('lz4');
});
```

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

### Define Bit and Varbit Columns

Source: https://github.com/tpetry/laravel-postgresql-enhanced/blob/master/_autodocs/api-reference/blueprint-column-types.md

Use `bit` for fixed-length and `varbit` for variable-length bit strings in your schema.

```php
Schema::create('feature_flags', function (Blueprint $table) {
    $table->id();
    $table->bit('permissions', 32); // Fixed 32-bit flags
    $table->varbit('feature_bits'); // Variable-length flags
});
```

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

### createViewOrReplace

Source: https://github.com/tpetry/laravel-postgresql-enhanced/blob/master/_autodocs/api-reference/schema-builder.md

Creates or replaces a database view without dropping it first.

```APIDOC
## createViewOrReplace

### Description
Creates or replaces a view without dropping it.

### Method
`createViewOrReplace(string $name, Builder|string $query, array $columns = [])`

### Parameters
#### Path Parameters
- **name** (string) - Required - View name
- **query** (Builder|string) - Required - Query definition or query builder instance
- **columns** (array) - Optional - Custom column names
```

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

### Zero-Downtime Migrations Trait

Source: https://github.com/tpetry/laravel-postgresql-enhanced/blob/master/_autodocs/QUICK_REFERENCE.md

Implement zero-downtime migrations by using the ZeroDowntimeMigration trait and configuring timeouts.

```php
use ZeroDowntimeMigration;

private float $timeout = 5.0;
private float $timeoutUp = 5.0;
private float $timeoutDown = 5.0;
```

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

### Create Materialized View Migration

Source: https://github.com/tpetry/laravel-postgresql-enhanced/blob/master/_autodocs/README.md

Create a materialized view in the database for optimizing expensive queries.

```php
// Create materialized view for expensive queries
Schema::createMaterializedView(
    'monthly_sales',
    DB::table('orders')->selectRaw('...')->groupBy('...')
);
```

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

### Define Hstore Column

Source: https://github.com/tpetry/laravel-postgresql-enhanced/blob/master/_autodocs/QUICK_REFERENCE.md

Use `hstore` to define a column for storing key-value pairs.

```php
$table->hstore('column')
```

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

### Ordering: Standard and Nulls First/Last

Source: https://github.com/tpetry/laravel-postgresql-enhanced/blob/master/_autodocs/QUICK_REFERENCE.md

Order query results by a column, with options to specify ascending or descending order. Also supports explicitly ordering null values first or last.

```php
orderBy($column, 'asc|desc', 'default|first|last')
orderByNullsFirst($column, 'asc|desc')
orderByNullsLast($column, 'asc|desc')
```

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

### Create Table with Stored Uppercase Column

Source: https://github.com/tpetry/laravel-postgresql-enhanced/blob/master/README.md

Demonstrates creating a table with a dynamically computed uppercase column using `storedAs`. Shows the default Eloquent behavior where the computed column is not immediately available after creation or update, requiring a manual `refresh()`.

```php
use Tpetry\PostgresqlEnhanced\Schema\Blueprint;
use Tpetry\PostgresqlEnhanced\Support\Facades\Schema;

Schema::create('example', function (Blueprint $table) {
    $table->id();
    $table->string('text');
    $table->string('text_uppercase')->storedAs('UPPER(text)');
});

$example = Example::create(['text' => 'test']);
dump($example); // ['id' => 1, 'text' => 'test']

$example->refresh();
dump($example); // ['id' => 1, 'text' => 'test', 'text_uppercase' => 'TEST']

$example->fill(['text' => 'test2'])->save();
dump($example); // ['id' => 1, 'text' => 'test2']

$example->refresh();
dump($example); // ['id' => 1, 'text' => 'test', 'text_uppercase' => 'TEST2']
```

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

### Functions

Source: https://github.com/tpetry/laravel-postgresql-enhanced/blob/master/_autodocs/INDEX.md

Methods for creating and dropping PostgreSQL functions.

```APIDOC
## Functions

### Description
Methods for creating, replacing, and dropping PostgreSQL functions.

### Methods
- `createFunction(name, parameters, return, language, body, options)`
  - Options: `volatility`, `parallel`, `leakproof`, `calledOnNull`, `security`, `cost`, `searchPath`
- `createFunctionOrReplace(...)
- `dropFunction(name, arguments)`
- `dropFunctionIfExists(name, arguments)`
```

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

### Register PHPStan Extensions Manually

Source: https://github.com/tpetry/laravel-postgresql-enhanced/blob/master/_autodocs/configuration.md

If you are not using the `phpstan/extension-installer`, you can manually register the PHPStan extensions by including the provided configuration files in your `phpstan.neon` file.

```neon
# phpstan.neon
includes:
    - ./vendor/nunomaduro/larastan/extension.neon
    - ./vendor/tpetry/laravel-postgresql-enhanced/phpstan-extension.neon
```

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

### Create or Replace a View

Source: https://github.com/tpetry/laravel-postgresql-enhanced/blob/master/_autodocs/api-reference/schema-builder.md

The `createViewOrReplace` method allows you to create a new view or replace an existing one without needing to drop it first.

```php
public function createViewOrReplace(
    string $name,
    Builder|string $query,
    array $columns = []
): void
```

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

### Apply Index Where Clause

Source: https://github.com/tpetry/laravel-postgresql-enhanced/blob/master/_autodocs/QUICK_REFERENCE.md

Use the `where` clause to create a conditional index based on SQL criteria.

```php
->where('condition_sql')
```

```php
->where(fn($q) => $q->whereNull('column'))
```
Tokens:
Raw