SQLite support and AST for each driver

.devcontainer/Dockerfile

@@ -0,0 +1,19 @@
+FROM php:8.2-cli
+
+RUN apt-get update && apt-get install -y \
+    git \
+    curl \
+    wget \
+    unzip \
+    zip \
+    ca-certificates \
+    && rm -rf /var/lib/apt/lists/*
+
+RUN docker-php-ext-install \
+    pcntl \
+    sockets
+
+COPY --from=composer:2 /usr/bin/composer /usr/bin/composer
+
+ENV COMPOSER_ALLOW_SUPERUSER=1
+ENV COMPOSER_HOME=/composer

.devcontainer/devcontainer.json

@@ -0,0 +1,23 @@
+{
+	"name": "PHP",
+	"build": {
+		"dockerfile": "./Dockerfile",
+		"context": ".."
+	},
+	"customizations": {
+		"vscode": {
+			"extensions": [
+				"bmewburn.vscode-intelephense-client",
+				"xdebug.php-pack",
+				"devsense.phptools-vscode",
+				"mehedidracula.php-namespace-resolver",
+				"devsense.composer-php-vscode",
+				"phiter.phpstorm-snippets"
+			]
+		}
+	},
+	"forwardPorts": [
+		8080
+	],
+	"remoteUser": "root"
+}

.github/dependabot.yml

@@ -0,0 +1,12 @@
+# To get started with Dependabot version updates, you'll need to specify which
+# package ecosystems to update and where the package manifests are located.
+# Please see the documentation for more information:
+# https://docs.github.com/github/administering-a-repository/configuration-options-for-dependency-updates
+# https://containers.dev/guide/dependabot
+
+version: 2
+updates:
+ - package-ecosystem: "devcontainers"
+   directory: "/"
+   schedule:
+     interval: weekly

composer.json

@@ -22,7 +22,9 @@
     "require": {
         "php": "^8.2",
         "ext-pcntl": "*",
+        "ext-sockets": "*",
         "adbario/php-dot-notation": "^3.1",
+        "ahjdev/amphp-sqlite3": "dev-main",
         "amphp/cache": "^2.0",
         "amphp/cluster": "^2.0",
         "amphp/file": "^v3.0.0",

src/Database/Clause.php

@@ -5,29 +5,36 @@
 namespace Phenix\Database;
 
 use Closure;
+use Phenix\Database\Clauses\BasicWhereClause;
+use Phenix\Database\Clauses\SubqueryWhereClause;
+use Phenix\Database\Clauses\WhereClause;
 use Phenix\Database\Concerns\Query\HasWhereClause;
 use Phenix\Database\Concerns\Query\PrepareColumns;
-use Phenix\Database\Constants\LogicalOperator;
+use Phenix\Database\Constants\LogicalConnector;
 use Phenix\Database\Constants\Operator;
-use Phenix\Database\Constants\SQL;
 use Phenix\Database\Contracts\Builder;
 use Phenix\Util\Arr;
 
+use function count;
 use function is_array;
 
 abstract class Clause extends Grammar implements Builder
 {
     use HasWhereClause;
     use PrepareColumns;
 
+    /**
+     * @var array<int, WhereClause>
+     */
     protected array $clauses;
+
     protected array $arguments;
 
     protected function resolveWhereMethod(
         string $column,
         Operator $operator,
         Closure|array|string|int $value,
-        LogicalOperator $logicalConnector = LogicalOperator::AND
+        LogicalConnector $logicalConnector = LogicalConnector::AND
     ): void {
         if ($value instanceof Closure) {
             $this->whereSubquery(
@@ -46,7 +53,7 @@ protected function whereSubquery(
         Operator $comparisonOperator,
         string|null $column = null,
         Operator|null $operator = null,
-        LogicalOperator $logicalConnector = LogicalOperator::AND
+        LogicalConnector $logicalConnector = LogicalConnector::AND
     ): void {
         $builder = new Subquery($this->driver);
         $builder->select(['*']);
@@ -55,9 +62,16 @@ protected function whereSubquery(
 
         [$dml, $arguments] = $builder->toSql();
 
-        $value = $operator?->value . $dml;
+        $connector = count($this->clauses) === 0 ? null : $logicalConnector;
 
-        $this->pushClause(array_filter([$column, $comparisonOperator, $value]), $logicalConnector);
+        $this->clauses[] = new SubqueryWhereClause(
+            comparisonOperator: $comparisonOperator,
+            sql: trim($dml, '()'),
+            params: $arguments,
+            column: $column,
+            operator: $operator,
+            connector: $connector
+        );
 
         $this->arguments = array_merge($this->arguments, $arguments);
     }
@@ -66,21 +80,17 @@ protected function pushWhereWithArgs(
         string $column,
         Operator $operator,
         array|string|int $value,
-        LogicalOperator $logicalConnector = LogicalOperator::AND
+        LogicalConnector $logicalConnector = LogicalConnector::AND
     ): void {
-        $placeholders = is_array($value)
-            ? array_fill(0, count($value), SQL::PLACEHOLDER->value)
-            : SQL::PLACEHOLDER->value;
-
-        $this->pushClause([$column, $operator, $placeholders], $logicalConnector);
+        $this->pushClause(new BasicWhereClause($column, $operator, $value, null, true), $logicalConnector);
 
         $this->arguments = array_merge($this->arguments, (array) $value);
     }
 
-    protected function pushClause(array $where, LogicalOperator $logicalConnector = LogicalOperator::AND): void
+    protected function pushClause(WhereClause $where, LogicalConnector $logicalConnector = LogicalConnector::AND): void
     {
         if (count($this->clauses) > 0) {
-            array_unshift($where, $logicalConnector);
+            $where->setConnector($logicalConnector);
         }
 
         $this->clauses[] = $where;
@@ -92,7 +102,7 @@ protected function prepareClauses(array $clauses): array
             return array_map(function ($value) {
                 return match (true) {
                     $value instanceof Operator => $value->value,
-                    $value instanceof LogicalOperator => $value->value,
+                    $value instanceof LogicalConnector => $value->value,
                     is_array($value) => '(' . Arr::implodeDeeply($value, ', ') . ')',
                     default => $value,
                 };

src/Database/Clauses/BasicWhereClause.php

@@ -0,0 +1,81 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phenix\Database\Clauses;
+
+use Phenix\Database\Constants\LogicalConnector;
+use Phenix\Database\Constants\Operator;
+use Phenix\Database\Constants\SQL;
+
+use function count;
+use function is_array;
+
+class BasicWhereClause extends WhereClause
+{
+    protected string $column;
+
+    protected Operator $operator;
+
+    protected array|string|int $value;
+
+    protected bool $usePlaceholder;
+
+    public function __construct(
+        string $column,
+        Operator $operator,
+        array|string|int $value,
+        LogicalConnector|null $connector = null,
+        bool $usePlaceholder = false
+    ) {
+        $this->column = $column;
+        $this->operator = $operator;
+        $this->value = $value;
+        $this->connector = $connector;
+        $this->usePlaceholder = $usePlaceholder;
+    }
+
+    public function getColumn(): string
+    {
+        return $this->column;
+    }
+
+    public function getOperator(): Operator
+    {
+        return $this->operator;
+    }
+
+    public function getValue(): array|string|int
+    {
+        return $this->value;
+    }
+
+    public function renderValue(): string
+    {
+        if ($this->usePlaceholder) {
+            // In WHERE context with parameterized queries, use placeholder
+            if (is_array($this->value)) {
+                return '(' . implode(', ', array_fill(0, count($this->value), SQL::PLACEHOLDER->value)) . ')';
+            }
+
+            return SQL::PLACEHOLDER->value;
+        }
+
+        // In JOIN ON context, render the value directly (typically a column name)
+        return (string) $this->value;
+    }
+
+    public function getValueCount(): int
+    {
+        if (is_array($this->value)) {
+            return count($this->value);
+        }
+
+        return 1;
+    }
+
+    public function isInOperator(): bool
+    {
+        return $this->operator === Operator::IN || $this->operator === Operator::NOT_IN;
+    }
+}

src/Database/Clauses/BetweenWhereClause.php

@@ -0,0 +1,50 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phenix\Database\Clauses;
+
+use Phenix\Database\Constants\LogicalConnector;
+use Phenix\Database\Constants\Operator;
+use Phenix\Database\Constants\SQL;
+
+class BetweenWhereClause extends WhereClause
+{
+    protected string $column;
+
+    protected Operator $operator;
+
+    protected array $values;
+
+    public function __construct(
+        string $column,
+        Operator $operator, // BETWEEN or NOT_BETWEEN
+        array $values,
+        LogicalConnector|null $connector = null
+    ) {
+        $this->column = $column;
+        $this->operator = $operator;
+        $this->values = $values;
+        $this->connector = $connector;
+    }
+
+    public function getColumn(): string
+    {
+        return $this->column;
+    }
+
+    public function getOperator(): Operator
+    {
+        return $this->operator;
+    }
+
+    public function getValues(): array
+    {
+        return $this->values;
+    }
+
+    public function renderValue(): string
+    {
+        return SQL::PLACEHOLDER->value . ' AND ' . SQL::PLACEHOLDER->value;
+    }
+}

src/Database/Clauses/BooleanWhereClause.php

@@ -0,0 +1,41 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phenix\Database\Clauses;
+
+use Phenix\Database\Constants\LogicalConnector;
+use Phenix\Database\Constants\Operator;
+
+class BooleanWhereClause extends WhereClause
+{
+    protected string $column;
+
+    protected Operator $operator;
+
+    public function __construct(
+        string $column,
+        Operator $operator, // IS_TRUE or IS_FALSE
+        LogicalConnector|null $connector = null
+    ) {
+        $this->column = $column;
+        $this->operator = $operator;
+        $this->connector = $connector;
+    }
+
+    public function getColumn(): string
+    {
+        return $this->column;
+    }
+
+    public function getOperator(): Operator
+    {
+        return $this->operator;
+    }
+
+    public function renderValue(): string
+    {
+        // Boolean clauses (IS TRUE/IS FALSE) have no value part
+        return '';
+    }
+}

src/Database/Clauses/ColumnWhereClause.php

@@ -0,0 +1,50 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phenix\Database\Clauses;
+
+use Phenix\Database\Constants\LogicalConnector;
+use Phenix\Database\Constants\Operator;
+
+class ColumnWhereClause extends WhereClause
+{
+    protected string $column;
+
+    protected Operator $operator;
+
+    protected string $compareColumn;
+
+    public function __construct(
+        string $column,
+        Operator $operator,
+        string $compareColumn,
+        LogicalConnector|null $connector = null
+    ) {
+        $this->column = $column;
+        $this->operator = $operator;
+        $this->compareColumn = $compareColumn;
+        $this->connector = $connector;
+    }
+
+    public function getColumn(): string
+    {
+        return $this->column;
+    }
+
+    public function getOperator(): Operator
+    {
+        return $this->operator;
+    }
+
+    public function getCompareColumn(): string
+    {
+        return $this->compareColumn;
+    }
+
+    public function renderValue(): string
+    {
+        // Column comparisons use the column name directly, not a placeholder
+        return $this->compareColumn;
+    }
+}