diff --git a/typed_sql/lib/src/typed_sql.expr.dart b/typed_sql/lib/src/ast.expr.dart
similarity index 64%
rename from typed_sql/lib/src/typed_sql.expr.dart
rename to typed_sql/lib/src/ast.expr.dart
index 5067a30b..bd3df11a 100644
--- a/typed_sql/lib/src/typed_sql.expr.dart
+++ b/typed_sql/lib/src/ast.expr.dart
@@ -12,139 +12,33 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-part of 'typed_sql.dart';
-
-sealed class _ExprType<T extends Object?> {
-  T? _read(RowReader r);
-
-  const _ExprType._();
-}
-
-sealed class FieldType<T extends Object?> extends _ExprType<T> {
-  const FieldType._() : super._();
-}
-
-/// A type that can appear in a database column.
+/// The SQL expression AST shared between the query-builder
+/// (`typed_sql.dart`) and the SQL dialects (`dialect/`).
 ///
-/// @nodoc
-sealed class ColumnType<T extends Object?> extends FieldType<T> {
-  const ColumnType._() : super._();
-
-  static const ColumnType<Uint8List> blob = _BlobExprType._();
-  static const ColumnType<bool> boolean = _BooleanExprType._();
-  static const ColumnType<DateTime> dateTime = _DateTimeExprType._();
-  static const ColumnType<int> integer = _IntegerExprType._();
-  static const ColumnType<double> real = _RealExprType._();
-  static const ColumnType<String> text = _TextExprType._();
-  static const ColumnType<Null> nullType = _NullExprType._();
-  static const ColumnType<JsonValue> jsonValue = _JsonValueExprType._();
-}
-
-final class _BlobExprType extends ColumnType<Uint8List> {
-  const _BlobExprType._() : super._();
-
-  @override
-  Uint8List? _read(RowReader r) => r.readUint8List();
-}
-
-final class _BooleanExprType extends ColumnType<bool> {
-  const _BooleanExprType._() : super._();
-
-  @override
-  bool? _read(RowReader r) => r.readBool();
-}
-
-final class _DateTimeExprType extends ColumnType<DateTime> {
-  const _DateTimeExprType._() : super._();
-
-  @override
-  DateTime? _read(RowReader r) => r.readDateTime();
-}
-
-final class _IntegerExprType extends ColumnType<int> {
-  const _IntegerExprType._() : super._();
-
-  @override
-  int? _read(RowReader r) => r.readInt();
-}
-
-final class _RealExprType extends ColumnType<double> {
-  const _RealExprType._() : super._();
-
-  @override
-  double? _read(RowReader r) => r.readDouble();
-}
-
-final class _TextExprType extends ColumnType<String> {
-  const _TextExprType._() : super._();
-
-  @override
-  String? _read(RowReader r) => r.readString();
-}
-
-final class _JsonValueExprType extends ColumnType<JsonValue> {
-  const _JsonValueExprType._() : super._();
-
-  @override
-  JsonValue? _read(RowReader r) => r.readJsonValue();
-}
-
-final class _NullExprType extends ColumnType<Null> {
-  const _NullExprType._() : super._();
-
-  @override
-  Null _read(RowReader r) => r.tryReadNull()
-      ? null
-      : throw AssertionError(
-          'Expr<Null> should always be `null`!',
-        );
-
-  static Iterable<Expr> _explodedCastAs<T, S>(
-    Expr<T> value,
-    _ExprType<S> type,
-  ) => switch (type) {
-    _RowExprType<Row> type => type.fields.map(
-      (f) => CastExpression._(value, f),
-    ),
-    CustomExprType type => [CastExpression._(value, type._backingType)],
-    ColumnType type => [CastExpression._(value, type)],
-  };
-}
-
-final class CustomExprType<S, T extends CustomDataType<S>>
-    extends FieldType<T> {
-  final ColumnType<S> _backingType;
-  final T Function(S value) _fromDatabase;
-
-  const CustomExprType._(this._backingType, this._fromDatabase) : super._();
-
-  @override
-  T? _read(RowReader r) {
-    final value = _backingType._read(r);
-    if (value != null) {
-      return _fromDatabase(value);
-    }
-    return null;
-  }
-}
-
-final class _RowExprType<T extends Row> extends _ExprType<T> {
-  final List<ColumnType> fields;
-  final T? Function(RowReader r) _readRow;
-
-  // TODO: This class should probably be part of a table
-  // definition, instead of this way around, but we can refactor that later.
-  _RowExprType._(TableDefinition<T> table)
-    : _readRow = table.readRow,
-      fields = table.columnInfo.map((c) => c.type).toList(),
-      super._();
-
-  @override
-  T? _read(RowReader r) => _readRow(r);
-}
+/// This library is never exported from `package:typed_sql/typed_sql.dart`
+/// (except for [Expr] itself, which is genuinely public API).
+library;
+
+import 'dart:typed_data' show Uint8List;
+
+import 'adapter/adapter.dart' show RowReader;
+import 'ast.expr_types.dart'
+    show
+        ColumnType,
+        CustomExprType,
+        CustomExprTypeInternal,
+        ExprType,
+        ExprTypeInternal,
+        FieldType,
+        rowExprType,
+        rowFieldsOf;
+import 'ast.query.dart' show QueryClause, SelectFromClause;
+import 'typed_sql.dart' show DefaultValue, Row, TableDefinition;
+import 'types/custom_data_type.dart' show CustomDataType;
+import 'types/json_value.dart' show JsonValue;
 
 abstract final class _ExprTyped<T extends Object?> {
-  _ExprType<T> get _type;
+  ExprType<T> get _type;
 }
 
 /// A representation of an SQL expression with type `T`.
@@ -155,13 +49,13 @@ abstract final class _ExprTyped<T extends Object?> {
 sealed class Expr<T extends Object?> implements _ExprTyped<T> {
   factory Expr(T value) => toExpr(value);
 
-  const Expr._();
+  const Expr.internal();
 
   int get _columns;
 
   Expr<T> _standin(int index, Object handle);
   Expr<R> _field<R>(int index, FieldType<R> type);
-  T? _decode(RowReader r) => _type._read(r);
+  T? _decode(RowReader r) => _type.$read(r);
 
   Iterable<Expr<Object?>> _explode();
 
@@ -187,14 +81,14 @@ sealed class Expr<T extends Object?> implements _ExprTyped<T> {
 }
 
 sealed class SingleValueExpr<T extends Object?> extends Expr<T> {
-  const SingleValueExpr._() : super._();
+  const SingleValueExpr.internal() : super.internal();
 
   @override
   Iterable<Expr<T>> _explode() => [this];
 
   @override
   Expr<T> _standin(int index, Object handle) =>
-      FieldExpression._(index, handle, _type);
+      FieldExpression.internal(index, handle, _type);
 
   @override
   Expr<R> _field<R>(int index, FieldType<R> type) =>
@@ -295,13 +189,13 @@ final class RowExpression<T extends Row> extends Expr<T> {
 
   @override
   Expr<T> _standin(int index, Object handle) =>
-      RowExpression._(index, _table, handle);
+      RowExpression.internal(index, _table, handle);
 
   @override
   int get _columns => _table.columns.length;
 
   @override
-  Expr<R> _field<R>(int index, _ExprType<R> type) {
+  Expr<R> _field<R>(int index, ExprType<R> type) {
     if (index < 0 || index >= _table.columns.length) {
       throw ArgumentError.value(
         index,
@@ -310,56 +204,61 @@ final class RowExpression<T extends Row> extends Expr<T> {
             'at index $index',
       );
     }
-    return FieldExpression._(_index + index, _handle, type);
+    return FieldExpression.internal(_index + index, _handle, type);
   }
 
   @override
   Iterable<Expr<Object?>> _explode() => Iterable.generate(
     _columns,
-    (index) => _field<void>(index, _type.fields[index]),
+    (index) => _field<void>(index, _table.columnInfo[index].type),
   );
 
-  RowExpression._(this._index, this._table, this._handle) : super._();
+  RowExpression.internal(this._index, this._table, this._handle)
+    : super.internal();
 
   @override
-  _RowExprType<T> get _type => _RowExprType._(_table);
+  ExprType<T> get _type => rowExprType(_table);
 }
 
 final class FieldExpression<T> extends SingleValueExpr<T> {
   final int _index;
   final Object _handle;
   @override
-  final _ExprType<T> _type;
+  final ExprType<T> _type;
 
-  FieldExpression._(this._index, this._handle, this._type) : super._();
+  FieldExpression.internal(this._index, this._handle, this._type)
+    : super.internal();
 }
 
 final class SubQueryExpression<T> extends Expr<T> {
   final QueryClause query;
   final Expr<T> _value;
 
-  SubQueryExpression._(this.query, this._value) : super._();
+  SubQueryExpression.internal(this.query, this._value) : super.internal();
 
   @override
   int get _columns => _value._columns;
 
   @override
-  Iterable<Expr<Object?>> _explode() => switch (_type) {
-    _RowExprType<Row> type => Iterable.generate(
-      _columns,
-      (index) => _field<void>(index, type.fields[index]),
-    ),
-    _ => [this],
-  };
+  Iterable<Expr<Object?>> _explode() {
+    final fields = rowFieldsOf(_type);
+    if (fields != null) {
+      return Iterable.generate(
+        _columns,
+        (index) => _field<void>(index, fields[index]),
+      );
+    }
+    return [this];
+  }
 
   @override
   Expr<R> _field<R>(int index, FieldType<R> type) {
     final handle = Object();
-    return SubQueryExpression._(
-      SelectFromClause._(
+    return SubQueryExpression.internal(
+      SelectFromClause.internal(
         query,
         handle,
-        [FieldExpression._(index, handle, type)],
+        [FieldExpression.internal(index, handle, type)],
       ),
       _value._field<R>(index, type), // TODO: Is this correct?
     );
@@ -369,27 +268,27 @@ final class SubQueryExpression<T> extends Expr<T> {
   Expr<T> _standin(int index, Object handle) => _value._standin(index, handle);
 
   @override
-  _ExprType<T> get _type => _value._type;
+  ExprType<T> get _type => _value._type;
 }
 
 final class ExistsExpression extends SingleValueExpr<bool> with _ExprBoolean {
   final QueryClause query;
-  ExistsExpression._(this.query) : super._();
+  ExistsExpression.internal(this.query) : super.internal();
 }
 
 final class SumExpression<T extends num> extends SingleValueExpr<T> {
   final Expr<T?> value;
-  SumExpression._(this.value) : super._();
+  SumExpression.internal(this.value) : super.internal();
 
   @override
-  _ExprType<T> get _type => value._type as _ExprType<T>;
+  ExprType<T> get _type => value._type as ExprType<T>;
 }
 
 // NOTE: AVG returns NULL, if applied to the empty set of values, also it
 //       ignores NULL and will return NULL if applied to set of NULLs.
 final class AvgExpression extends SingleValueExpr<double?> {
   final Expr<num?> value;
-  AvgExpression._(this.value) : super._();
+  AvgExpression.internal(this.value) : super.internal();
 
   @override
   final _type = ColumnType.real;
@@ -397,36 +296,36 @@ final class AvgExpression extends SingleValueExpr<double?> {
 
 final class MinExpression<T extends Comparable> extends SingleValueExpr<T?> {
   final Expr<T?> value;
-  MinExpression._(this.value) : super._();
+  MinExpression.internal(this.value) : super.internal();
 
   @override
-  _ExprType<T?> get _type => value._type;
+  ExprType<T?> get _type => value._type;
 }
 
 final class MaxExpression<T extends Comparable> extends SingleValueExpr<T?> {
   final Expr<T?> value;
-  MaxExpression._(this.value) : super._();
+  MaxExpression.internal(this.value) : super.internal();
 
   @override
-  _ExprType<T?> get _type => value._type;
+  ExprType<T?> get _type => value._type;
 }
 
 final class CountAllExpression extends SingleValueExpr<int> with _ExprInteger {
-  CountAllExpression._() : super._();
+  CountAllExpression.internal() : super.internal();
 }
 
 final class OrElseExpression<T> extends SingleValueExpr<T> {
   final Expr<T?> value;
   final Expr<T> orElse;
 
-  OrElseExpression._(this.value, this.orElse) : super._();
+  OrElseExpression.internal(this.value, this.orElse) : super.internal();
 
   @override
-  _ExprType<T> get _type {
+  ExprType<T> get _type {
     if (value._type == ColumnType.nullType) {
       return orElse._type;
     }
-    return value._type as _ExprType<T>; // TODO: Is this actually correct?
+    return value._type as ExprType<T>; // TODO: Is this actually correct?
   }
 }
 
@@ -438,19 +337,19 @@ final class NotNullExpression<T> extends Expr<T> {
 
   // TODO: Does this actually work?
   @override
-  _ExprType<T> get _type => value._type as _ExprType<T>;
+  ExprType<T> get _type => value._type as ExprType<T>;
 
   @override
   Iterable<Expr<Object?>> _explode() => value._explode();
 
   @override
   Expr<T> _standin(int index, Object handle) =>
-      NotNullExpression._(value._standin(index, handle));
+      NotNullExpression.internal(value._standin(index, handle));
 
   @override
   Expr<R> _field<R>(int index, FieldType<R> type) => value._field(index, type);
 
-  NotNullExpression._(this.value) : super._();
+  NotNullExpression.internal(this.value) : super.internal();
 }
 
 final class EncodedCustomDataTypeExpression<S, T extends CustomDataType<S>>
@@ -461,19 +360,19 @@ final class EncodedCustomDataTypeExpression<S, T extends CustomDataType<S>>
   int get _columns => value._columns;
 
   @override
-  _ExprType<S> get _type => (value._type as CustomExprType<S, T>)._backingType;
+  ExprType<S> get _type => (value._type as CustomExprType<S, T>).$backingType;
 
-  EncodedCustomDataTypeExpression._(this.value) : super._();
+  EncodedCustomDataTypeExpression.internal(this.value) : super.internal();
 }
 
 final class CastExpression<T, R> extends SingleValueExpr<R> {
   final Expr<T> value;
   final ColumnType<R> type;
 
-  CastExpression._(this.value, this.type) : super._();
+  CastExpression.internal(this.value, this.type) : super.internal();
 
   @override
-  _ExprType<R> get _type => type;
+  ExprType<R> get _type => type;
 }
 
 final class LiteralExpression<T> extends SingleValueExpr<T> {
@@ -484,26 +383,38 @@ final class LiteralExpression<T> extends SingleValueExpr<T> {
 
   ColumnType<Object?> get type => switch (_type) {
     ColumnType<T> t => t,
-    CustomExprType t => t._backingType,
+    CustomExprType t => t.$backingType,
   };
 
-  static final _true$ = LiteralExpression._(true, ColumnType.boolean);
-  static final _false$ = LiteralExpression._(false, ColumnType.boolean);
+  static final _true$ = LiteralExpression.internal(true, ColumnType.boolean);
+  static final _false$ = LiteralExpression.internal(false, ColumnType.boolean);
 
-  LiteralExpression._(this.value, this._type) : super._();
+  LiteralExpression.internal(this.value, this._type) : super.internal();
 
   factory LiteralExpression(T value) {
     // Switch over _Dummy<T> such that toExprLiteral<T?>(value) becomes an
     // instance of Expr<T?> even if value is `null`.
     switch (_Dummy<T>()) {
       case _Dummy<Null>():
-        return LiteralExpression._(value, ColumnType.nullType as FieldType<T>);
+        return LiteralExpression.internal(
+          value,
+          ColumnType.nullType as FieldType<T>,
+        );
       case _Dummy<String?>():
-        return LiteralExpression._(value, ColumnType.text as FieldType<T>);
+        return LiteralExpression.internal(
+          value,
+          ColumnType.text as FieldType<T>,
+        );
       case _Dummy<int?>():
-        return LiteralExpression._(value, ColumnType.integer as FieldType<T>);
+        return LiteralExpression.internal(
+          value,
+          ColumnType.integer as FieldType<T>,
+        );
       case _Dummy<double?>():
-        return LiteralExpression._(value, ColumnType.real as FieldType<T>);
+        return LiteralExpression.internal(
+          value,
+          ColumnType.real as FieldType<T>,
+        );
       case _Dummy<bool?>():
         switch (value) {
           case true:
@@ -511,20 +422,29 @@ final class LiteralExpression<T> extends SingleValueExpr<T> {
           case false:
             return _false$ as LiteralExpression<T>;
           default: // null
-            return LiteralExpression._(
+            return LiteralExpression.internal(
               value,
               ColumnType.boolean as FieldType<T>,
             );
         }
       case _Dummy<DateTime?>():
-        return LiteralExpression._(value, ColumnType.dateTime as FieldType<T>);
+        return LiteralExpression.internal(
+          value,
+          ColumnType.dateTime as FieldType<T>,
+        );
       case _Dummy<Uint8List?>():
-        return LiteralExpression._(value, ColumnType.blob as FieldType<T>);
+        return LiteralExpression.internal(
+          value,
+          ColumnType.blob as FieldType<T>,
+        );
       case _Dummy<JsonValue?>():
-        return LiteralExpression._(value, ColumnType.jsonValue as FieldType<T>);
+        return LiteralExpression.internal(
+          value,
+          ColumnType.jsonValue as FieldType<T>,
+        );
       case _Dummy<CustomDataType?>():
         if (value == null) {
-          return LiteralExpression<Null>._(null, ColumnType.nullType)
+          return LiteralExpression<Null>.internal(null, ColumnType.nullType)
               as LiteralExpression<T>;
         }
         throw ArgumentError.value(
@@ -541,13 +461,13 @@ final class LiteralExpression<T> extends SingleValueExpr<T> {
         // we shall recover it.
         switch (value) {
           case String v:
-            return LiteralExpression<String>._(v, ColumnType.text)
+            return LiteralExpression<String>.internal(v, ColumnType.text)
                 as LiteralExpression<T>;
           case int v:
-            return LiteralExpression<int>._(v, ColumnType.integer)
+            return LiteralExpression<int>.internal(v, ColumnType.integer)
                 as LiteralExpression<T>;
           case double v:
-            return LiteralExpression<double>._(v, ColumnType.real)
+            return LiteralExpression<double>.internal(v, ColumnType.real)
                 as LiteralExpression<T>;
           case bool v:
             switch (v) {
@@ -557,16 +477,19 @@ final class LiteralExpression<T> extends SingleValueExpr<T> {
                 return _false$ as LiteralExpression<T>;
             }
           case DateTime v:
-            return LiteralExpression<DateTime>._(v, ColumnType.dateTime)
+            return LiteralExpression<DateTime>.internal(v, ColumnType.dateTime)
                 as LiteralExpression<T>;
           case Uint8List v:
-            return LiteralExpression<Uint8List>._(v, ColumnType.blob)
+            return LiteralExpression<Uint8List>.internal(v, ColumnType.blob)
                 as LiteralExpression<T>;
           case JsonValue v:
-            return LiteralExpression<JsonValue>._(v, ColumnType.jsonValue)
+            return LiteralExpression<JsonValue>.internal(
+                  v,
+                  ColumnType.jsonValue,
+                )
                 as LiteralExpression<T>;
           case null:
-            return LiteralExpression<Null>._(null, ColumnType.nullType)
+            return LiteralExpression<Null>.internal(null, ColumnType.nullType)
                 as LiteralExpression<T>;
           default:
             throw ArgumentError.value(
@@ -588,34 +511,58 @@ final class ValueExpression<T> extends SingleValueExpr<T> {
 
   ColumnType<Object?> get type => switch (_type) {
     ColumnType<T> t => t,
-    CustomExprType t => t._backingType,
+    CustomExprType t => t.$backingType,
   };
 
-  ValueExpression._(this.value, this._type) : super._();
+  ValueExpression.internal(this.value, this._type) : super.internal();
 
   factory ValueExpression(T value) {
     // Switch over _Dummy<T> such that toExpr<T?>(value) becomes an
     // instance of Expr<T?> even if value is `null`.
     switch (_Dummy<T>()) {
       case _Dummy<Null>():
-        return ValueExpression._(value, ColumnType.nullType as ColumnType<T>);
+        return ValueExpression.internal(
+          value,
+          ColumnType.nullType as ColumnType<T>,
+        );
       case _Dummy<String?>():
-        return ValueExpression._(value, ColumnType.text as ColumnType<T>);
+        return ValueExpression.internal(
+          value,
+          ColumnType.text as ColumnType<T>,
+        );
       case _Dummy<int?>():
-        return ValueExpression._(value, ColumnType.integer as ColumnType<T>);
+        return ValueExpression.internal(
+          value,
+          ColumnType.integer as ColumnType<T>,
+        );
       case _Dummy<double?>():
-        return ValueExpression._(value, ColumnType.real as ColumnType<T>);
+        return ValueExpression.internal(
+          value,
+          ColumnType.real as ColumnType<T>,
+        );
       case _Dummy<bool?>():
-        return ValueExpression._(value, ColumnType.boolean as ColumnType<T>);
+        return ValueExpression.internal(
+          value,
+          ColumnType.boolean as ColumnType<T>,
+        );
       case _Dummy<DateTime?>():
-        return ValueExpression._(value, ColumnType.dateTime as ColumnType<T>);
+        return ValueExpression.internal(
+          value,
+          ColumnType.dateTime as ColumnType<T>,
+        );
       case _Dummy<Uint8List?>():
-        return ValueExpression._(value, ColumnType.blob as ColumnType<T>);
+        return ValueExpression.internal(
+          value,
+          ColumnType.blob as ColumnType<T>,
+        );
       case _Dummy<JsonValue?>():
-        return ValueExpression._(value, ColumnType.jsonValue as ColumnType<T>);
+        return ValueExpression.internal(
+          value,
+          ColumnType.jsonValue as ColumnType<T>,
+        );
       case _Dummy<CustomDataType?>():
         if (value == null) {
-          return ValueExpression<Null>._(null, ColumnType.nullType)
+          return ValueExpression<Null>.internal(null, ColumnType.nullType)
               as ValueExpression<T>;
         }
         throw ArgumentError.value(
@@ -632,28 +579,28 @@ final class ValueExpression<T> extends SingleValueExpr<T> {
         // we shall recover it.
         switch (value) {
           case String v:
-            return ValueExpression<String>._(v, ColumnType.text)
+            return ValueExpression<String>.internal(v, ColumnType.text)
                 as ValueExpression<T>;
           case int v:
-            return ValueExpression<int>._(v, ColumnType.integer)
+            return ValueExpression<int>.internal(v, ColumnType.integer)
                 as ValueExpression<T>;
           case double v:
-            return ValueExpression<double>._(v, ColumnType.real)
+            return ValueExpression<double>.internal(v, ColumnType.real)
                 as ValueExpression<T>;
           case bool v:
-            return ValueExpression<bool>._(v, ColumnType.boolean)
+            return ValueExpression<bool>.internal(v, ColumnType.boolean)
                 as ValueExpression<T>;
           case DateTime v:
-            return ValueExpression<DateTime>._(v, ColumnType.dateTime)
+            return ValueExpression<DateTime>.internal(v, ColumnType.dateTime)
                 as ValueExpression<T>;
           case Uint8List v:
-            return ValueExpression<Uint8List>._(v, ColumnType.blob)
+            return ValueExpression<Uint8List>.internal(v, ColumnType.blob)
                 as ValueExpression<T>;
           case JsonValue v:
-            return ValueExpression<JsonValue>._(v, ColumnType.jsonValue)
+            return ValueExpression<JsonValue>.internal(v, ColumnType.jsonValue)
                 as ValueExpression<T>;
           case null:
-            return ValueExpression<Null>._(null, ColumnType.nullType)
+            return ValueExpression<Null>.internal(null, ColumnType.nullType)
                 as ValueExpression<T>;
           default:
             throw ArgumentError.value(
@@ -670,9 +617,9 @@ final class ValueExpression<T> extends SingleValueExpr<T> {
 final class _Dummy<T> {}
 
 final class CurrentTimestampExpression extends SingleValueExpr<DateTime> {
-  const CurrentTimestampExpression._() : super._();
+  const CurrentTimestampExpression.internal() : super.internal();
 
-  static const currentTimestamp = CurrentTimestampExpression._();
+  static const currentTimestamp = CurrentTimestampExpression.internal();
 
   @override
   final _type = ColumnType.dateTime;
@@ -681,15 +628,15 @@ final class CurrentTimestampExpression extends SingleValueExpr<DateTime> {
 sealed class BinaryOperationExpression<T, R> extends SingleValueExpr<R> {
   final Expr<T> left;
   final Expr<T> right;
-  BinaryOperationExpression(this.left, this.right) : super._();
+  BinaryOperationExpression(this.left, this.right) : super.internal();
 }
 
 final class ExpressionBoolNot<T extends bool?> extends SingleValueExpr<T> {
   final Expr<T> value;
-  ExpressionBoolNot(this.value) : super._();
+  ExpressionBoolNot(this.value) : super.internal();
 
   @override
-  _ExprType<T> get _type => ColumnType.boolean as _ExprType<T>;
+  ExprType<T> get _type => ColumnType.boolean as ExprType<T>;
 }
 
 /// SQL Expression using `IS TRUE`.
@@ -697,7 +644,7 @@ final class ExpressionBoolNot<T extends bool?> extends SingleValueExpr<T> {
 /// Collapsing `Expr<bool?>` to `Expr<bool>` by interpreting `NULL` as `FALSE`.
 final class ExpressionIsTrue extends SingleValueExpr<bool> with _ExprBoolean {
   final Expr<bool?> value;
-  ExpressionIsTrue(this.value) : super._();
+  ExpressionIsTrue(this.value) : super.internal();
 }
 
 /// SQL Expression using `IS FALSE`.
@@ -705,13 +652,13 @@ final class ExpressionIsTrue extends SingleValueExpr<bool> with _ExprBoolean {
 /// Collapsing `Expr<bool?>` to `Expr<bool>` by interpreting `NULL` as `TRUE`.
 final class ExpressionIsFalse extends SingleValueExpr<bool> with _ExprBoolean {
   final Expr<bool?> value;
-  ExpressionIsFalse(this.value) : super._();
+  ExpressionIsFalse(this.value) : super.internal();
 }
 
 final class ExpressionBoolAnd<T extends bool?>
     extends BinaryOperationExpression<T, T> {
   @override
-  _ExprType<T> get _type => ColumnType.boolean as _ExprType<T>;
+  ExprType<T> get _type => ColumnType.boolean as ExprType<T>;
 
   ExpressionBoolAnd(super.left, super.right);
 }
@@ -719,7 +666,7 @@ final class ExpressionBoolAnd<T extends bool?>
 final class ExpressionBoolOr<T extends bool?>
     extends BinaryOperationExpression<T, T> {
   @override
-  _ExprType<T> get _type => ColumnType.boolean as _ExprType<T>;
+  ExprType<T> get _type => ColumnType.boolean as ExprType<T>;
 
   ExpressionBoolOr(super.left, super.right);
 }
@@ -780,53 +727,53 @@ final class ExpressionGreaterThanOrEqual<T extends Object>
 final class ExpressionStringIsEmpty extends SingleValueExpr<bool>
     with _ExprBoolean {
   final Expr<String> value;
-  ExpressionStringIsEmpty(this.value) : super._();
+  ExpressionStringIsEmpty(this.value) : super.internal();
 }
 
 final class ExpressionStringLength extends SingleValueExpr<int>
     with _ExprInteger {
   final Expr<String> value;
-  ExpressionStringLength(this.value) : super._();
+  ExpressionStringLength(this.value) : super.internal();
 }
 
 final class ExpressionStringStartsWith extends SingleValueExpr<bool>
     with _ExprBoolean {
   final Expr<String> value;
   final Expr<String> prefix;
-  ExpressionStringStartsWith(this.value, this.prefix) : super._();
+  ExpressionStringStartsWith(this.value, this.prefix) : super.internal();
 }
 
 final class ExpressionStringEndsWith extends SingleValueExpr<bool>
     with _ExprBoolean {
   final Expr<String> value;
   final Expr<String> suffix;
-  ExpressionStringEndsWith(this.value, this.suffix) : super._();
+  ExpressionStringEndsWith(this.value, this.suffix) : super.internal();
 }
 
 final class ExpressionStringLike extends SingleValueExpr<bool>
     with _ExprBoolean {
   final Expr<String> value;
   final String pattern;
-  ExpressionStringLike(this.value, this.pattern) : super._();
+  ExpressionStringLike(this.value, this.pattern) : super.internal();
 }
 
 final class ExpressionStringContains extends SingleValueExpr<bool>
     with _ExprBoolean {
   final Expr<String> value;
   final Expr<String> needle;
-  ExpressionStringContains(this.value, this.needle) : super._();
+  ExpressionStringContains(this.value, this.needle) : super.internal();
 }
 
 final class ExpressionStringToUpperCase extends SingleValueExpr<String>
     with _ExprText {
   final Expr<String> value;
-  ExpressionStringToUpperCase(this.value) : super._();
+  ExpressionStringToUpperCase(this.value) : super.internal();
 }
 
 final class ExpressionStringToLowerCase extends SingleValueExpr<String>
     with _ExprText {
   final Expr<String> value;
-  ExpressionStringToLowerCase(this.value) : super._();
+  ExpressionStringToLowerCase(this.value) : super.internal();
 }
 
 final class ExpressionNumAdd<T extends num>
@@ -834,7 +781,7 @@ final class ExpressionNumAdd<T extends num>
   ExpressionNumAdd(super.left, super.right);
 
   @override
-  _ExprType<T> get _type => left._type;
+  ExprType<T> get _type => left._type;
 }
 
 final class ExpressionNumSubtract<T extends num>
@@ -842,7 +789,7 @@ final class ExpressionNumSubtract<T extends num>
   ExpressionNumSubtract(super.left, super.right);
 
   @override
-  _ExprType<T> get _type => left._type;
+  ExprType<T> get _type => left._type;
 }
 
 final class ExpressionNumMultiply<T extends num>
@@ -850,7 +797,7 @@ final class ExpressionNumMultiply<T extends num>
   ExpressionNumMultiply(super.left, super.right);
 
   @override
-  _ExprType<T> get _type => left._type;
+  ExprType<T> get _type => left._type;
 }
 
 final class ExpressionNumDivide<T extends num>
@@ -862,7 +809,7 @@ final class ExpressionNumDivide<T extends num>
 final class ExpressionBlobLength extends SingleValueExpr<int>
     with _ExprInteger {
   final Expr<Uint8List> value;
-  ExpressionBlobLength(this.value) : super._();
+  ExpressionBlobLength(this.value) : super.internal();
 }
 
 final class ExpressionBlobConcat
@@ -873,7 +820,7 @@ final class ExpressionBlobConcat
 
 final class ExpressionBlobToHex extends SingleValueExpr<String> with _ExprText {
   final Expr<Uint8List> value;
-  ExpressionBlobToHex(this.value) : super._();
+  ExpressionBlobToHex(this.value) : super.internal();
 }
 
 final class ExpressionBlobSublist extends SingleValueExpr<Uint8List>
@@ -883,19 +830,20 @@ final class ExpressionBlobSublist extends SingleValueExpr<Uint8List>
   /// Start index of the substring, zero-indexed (like in Dart).
   final Expr<int> start;
   final Expr<int>? length;
-  ExpressionBlobSublist(this.value, this.start, [this.length]) : super._();
+  ExpressionBlobSublist(this.value, this.start, [this.length])
+    : super.internal();
 }
 
 final class ExpressionBlobDecodeUtf8 extends SingleValueExpr<String>
     with _ExprText {
   final Expr<Uint8List> value;
-  ExpressionBlobDecodeUtf8(this.value) : super._();
+  ExpressionBlobDecodeUtf8(this.value) : super.internal();
 }
 
 /// Base class for JSON expressions reference a property or index in a
 /// [JsonValue].
 sealed class ExpressionJsonRef extends SingleValueExpr<JsonValue?> {
-  ExpressionJsonRef._() : super._();
+  ExpressionJsonRef.internal() : super.internal();
 
   @override
   final _type = ColumnType.jsonValue;
@@ -905,7 +853,7 @@ sealed class ExpressionJsonRef extends SingleValueExpr<JsonValue?> {
 final class ExpressionJsonRefRoot extends ExpressionJsonRef {
   final Expr<JsonValue?> value;
 
-  ExpressionJsonRefRoot._(this.value) : super._();
+  ExpressionJsonRefRoot.internal(this.value) : super.internal();
 }
 
 /// Accessing a key in a JSON object, using `value -> 'key'` in SQL.
@@ -913,7 +861,7 @@ final class ExpressionJsonRefKey extends ExpressionJsonRef {
   final ExpressionJsonRef value;
   final String key;
 
-  ExpressionJsonRefKey._(this.value, this.key) : super._();
+  ExpressionJsonRefKey.internal(this.value, this.key) : super.internal();
 }
 
 /// Accessing a key in a JSON object, using `value -> index` in SQL.
@@ -921,7 +869,7 @@ final class ExpressionJsonRefIndex extends ExpressionJsonRef {
   final ExpressionJsonRef value;
   final int index;
 
-  ExpressionJsonRefIndex._(this.value, this.index) : super._();
+  ExpressionJsonRefIndex.internal(this.value, this.index) : super.internal();
 }
 
 /// Extract a raw TEXT representation from a ExpressionJsonRef into a
@@ -929,8 +877,32 @@ final class ExpressionJsonRefIndex extends ExpressionJsonRef {
 final class ExpressionJsonExtract extends SingleValueExpr<String?> {
   final Expr<JsonValue?> value;
 
-  ExpressionJsonExtract._(this.value) : super._();
+  ExpressionJsonExtract.internal(this.value) : super.internal();
 
   @override
-  _ExprType<String?> get _type => ColumnType.text;
+  ExprType<String?> get _type => ColumnType.text;
+}
+
+/// Package-internal view of [Expr], exposing members used by the
+/// query-builder and SQL dialects without making them part of [Expr]'s own
+/// (public) API.
+///
+/// Members are prefixed with `$` (matching the `$ForGeneratedCode`
+/// convention) so they can't collide with a generated per-model extension
+/// member named after a user's column (e.g. a column named `field`).
+extension ExprInternal<T extends Object?> on Expr<T> {
+  ExprType<T> get $exprType => _type;
+  int get $columnCount => _columns;
+  Expr<T> $standin(int index, Object handle) => _standin(index, handle);
+  Expr<R> $field<R>(int index, FieldType<R> type) => _field(index, type);
+  T? $decode(RowReader r) => _decode(r);
+  Iterable<Expr<Object?>> $explode() => _explode();
+}
+
+/// Package-internal view of [FieldExpression], exposing members used by the
+/// query-builder without making them part of [FieldExpression]'s own
+/// (still private) API.
+extension FieldExpressionInternal<T extends Object?> on FieldExpression<T> {
+  Object get $handle => _handle;
+  int get $index => _index;
 }
diff --git a/typed_sql/lib/src/ast.expr_types.dart b/typed_sql/lib/src/ast.expr_types.dart
new file mode 100644
index 00000000..16127dd9
--- /dev/null
+++ b/typed_sql/lib/src/ast.expr_types.dart
@@ -0,0 +1,189 @@
+// Copyright 2025 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+/// The SQL column-type system shared between the query-builder
+/// (`typed_sql.dart`) and the SQL dialects (`dialect/`).
+///
+/// This library is never exported from `package:typed_sql/typed_sql.dart`.
+library;
+
+import 'dart:typed_data' show Uint8List;
+
+import 'adapter/adapter.dart' show RowReader;
+import 'ast.expr.dart' show CastExpression, Expr;
+import 'typed_sql.dart' show Row, TableDefinition;
+import 'types/custom_data_type.dart' show CustomDataType;
+import 'types/json_value.dart' show JsonValue;
+
+sealed class ExprType<T extends Object?> {
+  T? _read(RowReader r);
+
+  const ExprType._();
+}
+
+sealed class FieldType<T extends Object?> extends ExprType<T> {
+  const FieldType._() : super._();
+}
+
+/// A type that can appear in a database column.
+///
+/// @nodoc
+sealed class ColumnType<T extends Object?> extends FieldType<T> {
+  const ColumnType._() : super._();
+
+  static const ColumnType<Uint8List> blob = _BlobExprType._();
+  static const ColumnType<bool> boolean = _BooleanExprType._();
+  static const ColumnType<DateTime> dateTime = _DateTimeExprType._();
+  static const ColumnType<int> integer = _IntegerExprType._();
+  static const ColumnType<double> real = _RealExprType._();
+  static const ColumnType<String> text = _TextExprType._();
+  static const ColumnType<Null> nullType = _NullExprType._();
+  static const ColumnType<JsonValue> jsonValue = _JsonValueExprType._();
+}
+
+final class _BlobExprType extends ColumnType<Uint8List> {
+  const _BlobExprType._() : super._();
+
+  @override
+  Uint8List? _read(RowReader r) => r.readUint8List();
+}
+
+final class _BooleanExprType extends ColumnType<bool> {
+  const _BooleanExprType._() : super._();
+
+  @override
+  bool? _read(RowReader r) => r.readBool();
+}
+
+final class _DateTimeExprType extends ColumnType<DateTime> {
+  const _DateTimeExprType._() : super._();
+
+  @override
+  DateTime? _read(RowReader r) => r.readDateTime();
+}
+
+final class _IntegerExprType extends ColumnType<int> {
+  const _IntegerExprType._() : super._();
+
+  @override
+  int? _read(RowReader r) => r.readInt();
+}
+
+final class _RealExprType extends ColumnType<double> {
+  const _RealExprType._() : super._();
+
+  @override
+  double? _read(RowReader r) => r.readDouble();
+}
+
+final class _TextExprType extends ColumnType<String> {
+  const _TextExprType._() : super._();
+
+  @override
+  String? _read(RowReader r) => r.readString();
+}
+
+final class _JsonValueExprType extends ColumnType<JsonValue> {
+  const _JsonValueExprType._() : super._();
+
+  @override
+  JsonValue? _read(RowReader r) => r.readJsonValue();
+}
+
+final class _NullExprType extends ColumnType<Null> {
+  const _NullExprType._() : super._();
+
+  @override
+  Null _read(RowReader r) => r.tryReadNull()
+      ? null
+      : throw AssertionError(
+          'Expr<Null> should always be `null`!',
+        );
+}
+
+/// Cast [value] (whose static type is unknown, e.g. an untyped `NULL`) to
+/// match [type], exploding row types into one [CastExpression] per field.
+Iterable<Expr> explodedCastAs<T, S>(
+  Expr<T> value,
+  ExprType<S> type,
+) => switch (type) {
+  _RowExprType<Row> type => type.fields.map(
+    (f) => CastExpression.internal(value, f),
+  ),
+  CustomExprType type => [CastExpression.internal(value, type._backingType)],
+  ColumnType type => [CastExpression.internal(value, type)],
+};
+
+final class CustomExprType<S, T extends CustomDataType<S>>
+    extends FieldType<T> {
+  final ColumnType<S> _backingType;
+  final T Function(S value) _fromDatabase;
+
+  const CustomExprType.internal(this._backingType, this._fromDatabase)
+    : super._();
+
+  @override
+  T? _read(RowReader r) {
+    final value = _backingType._read(r);
+    if (value != null) {
+      return _fromDatabase(value);
+    }
+    return null;
+  }
+}
+
+final class _RowExprType<T extends Row> extends ExprType<T> {
+  final List<ColumnType> fields;
+  final T? Function(RowReader r) _readRow;
+
+  // TODO: This class should probably be part of a table
+  // definition, instead of this way around, but we can refactor that later.
+  _RowExprType._(TableDefinition<T> table)
+    : _readRow = table.readRow,
+      fields = table.columnInfo.map((c) => c.type).toList(),
+      super._();
+
+  @override
+  T? _read(RowReader r) => _readRow(r);
+}
+
+/// Get the [ExprType] describing rows of [table].
+ExprType<T> rowExprType<T extends Row>(TableDefinition<T> table) =>
+    _RowExprType._(table);
+
+/// If [type] describes a row (e.g. a whole table row), returns the
+/// [ColumnType] of each of its fields; otherwise returns `null`.
+List<ColumnType>? rowFieldsOf(ExprType type) => switch (type) {
+  _RowExprType t => t.fields,
+  _ => null,
+};
+
+/// Package-internal view of [ExprType], exposing members used by the
+/// query-builder and SQL dialects without making them part of [ExprType]'s
+/// own (still private) API.
+///
+/// Members are prefixed with `$` (matching the `$ForGeneratedCode`
+/// convention) so they can't collide with a generated per-model extension
+/// member named after a user's column.
+extension ExprTypeInternal<T extends Object?> on ExprType<T> {
+  T? $read(RowReader r) => _read(r);
+}
+
+/// Package-internal view of [CustomExprType], exposing members used by the
+/// query-builder and SQL dialects without making them part of
+/// [CustomExprType]'s own (still private) API.
+extension CustomExprTypeInternal<S, T extends CustomDataType<S>>
+    on CustomExprType<S, T> {
+  ColumnType<S> get $backingType => _backingType;
+}
diff --git a/typed_sql/lib/src/ast.query.dart b/typed_sql/lib/src/ast.query.dart
new file mode 100644
index 00000000..f7ce36fd
--- /dev/null
+++ b/typed_sql/lib/src/ast.query.dart
@@ -0,0 +1,248 @@
+// Copyright 2025 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+/// The SQL query-clause / statement AST shared between the query-builder
+/// (`typed_sql.dart`) and the SQL dialects (`dialect/`).
+///
+/// This library is never exported from `package:typed_sql/typed_sql.dart`.
+library;
+
+import 'ast.expr.dart'
+    show Expr, ExprInternal, FieldExpression, FieldExpressionInternal;
+import 'ast.expr_types.dart' show ColumnType;
+import 'typed_sql.dart'
+    show
+        ColumnDefinition,
+        ForeignKeyDefinition,
+        IndexDefinition,
+        JoinType,
+        Order,
+        TableDefinition;
+
+part 'ast.statements.dart';
+
+/* --------------------- Query clauses ---------------------- */
+
+sealed class QueryClause {}
+
+final class TableClause extends QueryClause {
+  final TableDefinition _definition;
+
+  /// Name of table
+  String get name => _definition.tableName;
+  List<String> get columns => _definition.columns;
+  List<String> get primaryKey => _definition.primaryKey;
+  List<ColumnDefinition> get columnInfo => _definition.columnInfo;
+
+  TableClause.internal(this._definition);
+}
+
+final class SelectClause extends QueryClause {
+  final List<Expr> _expressions;
+
+  Iterable<Expr> get expressions => _expressions.expand((e) => e.$explode());
+
+  SelectClause.internal(this._expressions);
+}
+
+sealed class FromClause extends QueryClause {
+  final QueryClause from;
+  FromClause.internal(this.from);
+}
+
+/// Interface implemented by object with-in which expressions may exist.
+///
+/// Expressions can be bound to this context, that is the context from which
+/// they are referencing fields.
+final class ExpressionContext {
+  final Object _handle;
+
+  ExpressionContext.internal(this._handle);
+}
+
+final class SelectFromClause extends FromClause implements ExpressionContext {
+  @override
+  final Object _handle;
+  final List<Expr> _projection;
+
+  Iterable<Expr> get projection => _projection.expand((e) => e.$explode());
+
+  SelectFromClause.internal(super.from, this._handle, this._projection)
+    : super.internal();
+}
+
+final class WhereClause extends FromClause implements ExpressionContext {
+  @override
+  final Object _handle;
+  final Expr<bool?> where;
+  WhereClause.internal(super.from, this._handle, this.where) : super.internal();
+}
+
+final class OrderByClause extends FromClause implements ExpressionContext {
+  @override
+  final Object _handle;
+  final List<(Expr<Comparable?>, Order)> orderBy;
+
+  OrderByClause.internal(
+    super.from,
+    this._handle,
+    this.orderBy,
+  ) : super.internal() {
+    if (orderBy.any((e) => e.$1.$columnCount > 1)) {
+      // This shouldn't be possible!
+      throw AssertionError(
+        'In Expr<T extends Row> T may not implement Comparable<T>, '
+        'using Expr<Row> in .orderBy is not supported!',
+      );
+    }
+  }
+}
+
+final class JoinClause extends FromClause implements ExpressionContext {
+  @override
+  final Object _handle;
+  final JoinType type;
+  final QueryClause join;
+  final Expr<bool?> on;
+
+  JoinClause.internal(
+    this._handle,
+    this.type,
+    super.from,
+    this.join,
+    this.on,
+  ) : super.internal();
+}
+
+final class LimitClause extends FromClause {
+  final int limit;
+  LimitClause.internal(super.from, this.limit) : super.internal();
+}
+
+final class OffsetClause extends FromClause {
+  final int offset;
+  OffsetClause.internal(super.from, this.offset) : super.internal();
+}
+
+final class DistinctClause extends FromClause {
+  DistinctClause.internal(super.from) : super.internal();
+}
+
+final class GroupByClause extends FromClause implements ExpressionContext {
+  @override
+  final Object _handle;
+
+  final List<Expr> _group;
+  final List<Expr> _aggregation;
+
+  /// The grouped columns (exploded).
+  late final List<Expr> groupBy = _group.expand((e) => e.$explode()).toList();
+
+  /// The projection is made up of the grouped columns followed by the
+  /// aggregations.
+  ///
+  /// We promise that [groupBy] is a prefix of [projection].
+  late final List<Expr> projection = [
+    ...groupBy,
+    ..._aggregation.expand((e) => e.$explode()),
+  ];
+
+  GroupByClause.internal(
+    super.from,
+    this._handle,
+    this._group,
+    this._aggregation,
+  ) : super.internal();
+}
+
+sealed class CompositeQueryClause extends QueryClause {
+  final QueryClause left;
+  final QueryClause right;
+  CompositeQueryClause.internal(this.left, this.right);
+}
+
+// make these subclass of composite queryclause
+final class UnionClause extends CompositeQueryClause {
+  UnionClause.internal(super.left, super.right) : super.internal();
+}
+
+final class UnionAllClause extends CompositeQueryClause {
+  UnionAllClause.internal(super.left, super.right) : super.internal();
+}
+
+final class IntersectClause extends CompositeQueryClause {
+  IntersectClause.internal(super.left, super.right) : super.internal();
+}
+
+final class ExceptClause extends CompositeQueryClause {
+  ExceptClause.internal(super.left, super.right) : super.internal();
+}
+
+/* --------------------- Auxiliary utils for SQL rendering------------------- */
+
+final class ExpressionResolver<T> {
+  final ExpressionResolver? _parent;
+  final Object _handle;
+  final List<(String?, String)> _columns;
+  final T context;
+
+  /// Depth of the scope in the query tree.
+  final int depth;
+
+  ExpressionResolver.internal(
+    this.context,
+    this._parent,
+    this._handle,
+    this._columns,
+    this.depth,
+  );
+
+  ExpressionResolver(T context) : this.internal(context, null, Object(), [], 0);
+
+  ExpressionResolver<T> withScope(
+    ExpressionContext ctx,
+    List<(String?, String)> columns,
+  ) => ExpressionResolver.internal(
+    context,
+    this,
+    ctx._handle,
+    columns,
+    depth + 1,
+  );
+
+  (String?, String) resolve(FieldExpression field) {
+    if (_handle == field.$handle) {
+      return _columns[field.$index];
+    }
+    if (_parent != null) {
+      return _parent.resolve(field);
+    }
+    throw ArgumentError.value(
+      field,
+      'field',
+      'cannot be resolved in the given context',
+    );
+  }
+}
+
+/// Package-internal view of [ExpressionContext], exposing members used by
+/// the query-builder without making them part of [ExpressionContext]'s own
+/// (still private) API.
+///
+/// Members are prefixed with `$` (matching the `$ForGeneratedCode`
+/// convention) so they can't collide with a generated per-model extension
+/// member named after a user's column.
+extension ExpressionContextInternal on ExpressionContext {
+  Object get $handle => _handle;
+}
diff --git a/typed_sql/lib/src/typed_sql.statements.dart b/typed_sql/lib/src/ast.statements.dart
similarity index 84%
rename from typed_sql/lib/src/typed_sql.statements.dart
rename to typed_sql/lib/src/ast.statements.dart
index 4c667222..d7bad7d6 100644
--- a/typed_sql/lib/src/typed_sql.statements.dart
+++ b/typed_sql/lib/src/ast.statements.dart
@@ -12,7 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-part of 'typed_sql.dart';
+part of 'ast.query.dart';
 
 sealed class SqlStatement {}
 
@@ -42,7 +42,7 @@ final class CreateTableStatement extends SqlStatement {
   final List<ForeignKeyDefinition> foreignKeys;
   final List<IndexDefinition> indexes;
 
-  CreateTableStatement._({
+  CreateTableStatement.internal({
     required this.tableName,
     required this.primaryKey,
     required this.columns,
@@ -54,7 +54,7 @@ final class CreateTableStatement extends SqlStatement {
 
 final class SelectStatement extends SqlStatement {
   final QueryClause query;
-  SelectStatement._(this.query);
+  SelectStatement.internal(this.query);
 }
 
 final class InsertStatement extends SqlStatement {
@@ -63,7 +63,7 @@ final class InsertStatement extends SqlStatement {
   final ConflictClause? onConflict;
   final ReturningClause? returning;
 
-  InsertStatement._(
+  InsertStatement.internal(
     this.table,
     this.values,
     this.onConflict,
@@ -83,7 +83,7 @@ final class ExprValuesSource extends ValuesSource {
   final List<String> columns;
   final List<Expr> values;
 
-  ExprValuesSource._(this.columns, this.values);
+  ExprValuesSource.internal(this.columns, this.values);
 }
 
 /// Source of values for an [InsertStatement] that inserts multiple rows from
@@ -98,17 +98,17 @@ final class BulkValuesSource extends ValuesSource {
   /// The `j` row for `columns[i]` has the value `columnValues[i][j]`.
   final List<Iterable<Object?>> columnValues;
 
-  BulkValuesSource._(this.columns, this.types, this.columnValues);
+  BulkValuesSource.internal(this.columns, this.types, this.columnValues);
 }
 
 sealed class ConflictClause {
   final List<String> conflictTarget;
 
-  ConflictClause._(this.conflictTarget);
+  ConflictClause.internal(this.conflictTarget);
 }
 
 final class DoNothingOnConflictClause extends ConflictClause {
-  DoNothingOnConflictClause._(super.conflictTarget) : super._();
+  DoNothingOnConflictClause.internal(super.conflictTarget) : super.internal();
 }
 
 final class UpdateOnConflictClause extends ConflictClause
@@ -122,7 +122,7 @@ final class UpdateOnConflictClause extends ConflictClause
   final List<Expr> values;
   final Expr<bool?> where;
 
-  UpdateOnConflictClause._(
+  UpdateOnConflictClause.internal(
     this._handle,
     super.conflictTarget,
     this.table,
@@ -130,7 +130,7 @@ final class UpdateOnConflictClause extends ConflictClause
     this.columns,
     this.values,
     this.where,
-  ) : super._();
+  ) : super.internal();
 }
 
 final class ReturningClause implements ExpressionContext {
@@ -139,9 +139,9 @@ final class ReturningClause implements ExpressionContext {
   final List<String> columns;
   final List<Expr> _projection;
 
-  Iterable<Expr> get projection => _projection.expand((e) => e._explode());
+  Iterable<Expr> get projection => _projection.expand((e) => e.$explode());
 
-  ReturningClause._(this._handle, this.columns, this._projection);
+  ReturningClause.internal(this._handle, this.columns, this._projection);
 }
 
 final class UpdateStatement extends SqlStatement implements ExpressionContext {
@@ -153,7 +153,7 @@ final class UpdateStatement extends SqlStatement implements ExpressionContext {
   final QueryClause where;
   final ReturningClause? returning;
 
-  UpdateStatement._(
+  UpdateStatement.internal(
     this.table,
     this.columns,
     this.values,
@@ -168,5 +168,5 @@ final class DeleteStatement extends SqlStatement {
   final QueryClause where;
   final ReturningClause? returning;
 
-  DeleteStatement._(this.table, this.where, this.returning);
+  DeleteStatement.internal(this.table, this.where, this.returning);
 }
diff --git a/typed_sql/lib/src/dialect/dialect.dart b/typed_sql/lib/src/dialect/dialect.dart
index 784f5965..5f1637e2 100644
--- a/typed_sql/lib/src/dialect/dialect.dart
+++ b/typed_sql/lib/src/dialect/dialect.dart
@@ -12,32 +12,21 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+import '../ast.query.dart';
 import '../sql_task.dart';
-import '../typed_sql.dart';
 import 'postgres_dialect.dart';
 import 'sqlite_dialect.dart';
 
-export '../sql_task.dart';
-export '../typed_sql.dart'
+export '../ast.expr.dart'
     show
         AvgExpression,
         BinaryOperationExpression,
-        BulkValuesSource,
         CastExpression,
-        ColumnType,
-        CompositeQueryClause,
-        ConflictClause,
         CountAllExpression,
-        CreateTableStatement,
         CurrentTimestampExpression,
-        DeleteStatement,
-        DistinctClause,
-        DoNothingOnConflictClause,
         EncodedCustomDataTypeExpression,
-        ExceptClause,
         ExistsExpression,
         Expr,
-        ExprValuesSource,
         ExpressionBlobConcat,
         ExpressionBlobDecodeUtf8,
         ExpressionBlobLength,
@@ -46,7 +35,6 @@ export '../typed_sql.dart'
         ExpressionBoolAnd,
         ExpressionBoolNot,
         ExpressionBoolOr,
-        ExpressionContext,
         ExpressionEquals,
         ExpressionGreaterThan,
         ExpressionGreaterThanOrEqual,
@@ -65,7 +53,6 @@ export '../typed_sql.dart'
         ExpressionNumDivide,
         ExpressionNumMultiply,
         ExpressionNumSubtract,
-        ExpressionResolver,
         ExpressionStringContains,
         ExpressionStringEndsWith,
         ExpressionStringIsEmpty,
@@ -75,38 +62,51 @@ export '../typed_sql.dart'
         ExpressionStringToLowerCase,
         ExpressionStringToUpperCase,
         FieldExpression,
+        LiteralExpression,
+        MaxExpression,
+        MinExpression,
+        NotNullExpression,
+        OrElseExpression,
+        RowExpression,
+        SubQueryExpression,
+        SumExpression,
+        ValueExpression;
+export '../ast.expr_types.dart' show ColumnType;
+export '../ast.query.dart'
+    show
+        BulkValuesSource,
+        CompositeQueryClause,
+        ConflictClause,
+        CreateTableStatement,
+        DeleteStatement,
+        DistinctClause,
+        DoNothingOnConflictClause,
+        ExceptClause,
+        ExprValuesSource,
+        ExpressionContext,
+        ExpressionResolver,
         FromClause,
         GroupByClause,
         InsertStatement,
         IntersectClause,
         JoinClause,
-        JoinType,
         LimitClause,
-        LiteralExpression,
-        MaxExpression,
-        MinExpression,
-        NotNullExpression,
         OffsetClause,
-        OrElseExpression,
-        Order,
         OrderByClause,
         QueryClause,
-        Row,
-        RowExpression,
         SelectClause,
         SelectFromClause,
         SelectStatement,
         SqlStatement,
-        SubQueryExpression,
-        SumExpression,
         TableClause,
         UnionAllClause,
         UnionClause,
         UpdateOnConflictClause,
         UpdateStatement,
-        ValueExpression,
         ValuesSource,
         WhereClause;
+export '../sql_task.dart';
+export '../typed_sql.dart' show JoinType, Order, Row;
 export '../types/custom_data_type.dart' show CustomDataType;
 export '../types/json_value.dart' show JsonValue;
 
diff --git a/typed_sql/lib/src/dialect/shared_dialect.dart b/typed_sql/lib/src/dialect/shared_dialect.dart
index 2ef93847..135a6dd2 100644
--- a/typed_sql/lib/src/dialect/shared_dialect.dart
+++ b/typed_sql/lib/src/dialect/shared_dialect.dart
@@ -12,6 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+import '../ast.query.dart';
 import '../typed_sql.dart';
 
 /// Returns the default SQL clause expression for the given referential actions.
diff --git a/typed_sql/lib/src/typed_sql.dart b/typed_sql/lib/src/typed_sql.dart
index e425de58..3da504eb 100644
--- a/typed_sql/lib/src/typed_sql.dart
+++ b/typed_sql/lib/src/typed_sql.dart
@@ -22,6 +22,9 @@ import 'package:collection/collection.dart';
 import 'package:meta/meta_meta.dart';
 
 import 'adapter/adapter.dart';
+import 'ast.expr.dart';
+import 'ast.expr_types.dart';
+import 'ast.query.dart';
 import 'dialect/dialect.dart'
     show PipelinedSqlTask, ScriptSqlTask, SingleSqlTask, SqlDialect, SqlTask;
 import 'types/custom_data_type.dart' show CustomDataType;
@@ -29,13 +32,11 @@ import 'types/json_value.dart' show JsonValue;
 
 part 'typed_sql.annotations.dart';
 part 'typed_sql.database.dart';
-part 'typed_sql.expr.dart';
 part 'typed_sql.expr_ext.dart';
 part 'typed_sql.g.dart';
 part 'typed_sql.mutation.dart';
 part 'typed_sql.query.dart';
 part 'typed_sql.query_ext.dart';
-part 'typed_sql.statements.dart';
 
 /// Marker class which all schema definitions must extend.
 ///
@@ -221,7 +222,7 @@ final class $ForGeneratedCode {
     final task = dialect.createTables(
       tables
           .map(
-            (t) => CreateTableStatement._(
+            (t) => CreateTableStatement.internal(
               tableName: t.tableName,
               primaryKey: t.primaryKey,
               columns: t.columns
@@ -264,7 +265,7 @@ final class $ForGeneratedCode {
     TableDefinition<T> table,
   ) => Table._(
     context,
-    TableClause._(table),
+    TableClause.internal(table),
     table,
   );
 
@@ -274,11 +275,11 @@ final class $ForGeneratedCode {
     required List<Object? Function(S)?> mappings,
   }) => Insert._(
     table: table,
-    values: BulkValuesSource._(
+    values: BulkValuesSource.internal(
       table._tableClause.columns
           .whereIndexed((index, value) => mappings[index] != null)
           .toList(),
-      table._tableClause._definition.columnInfo
+      table._tableClause.columnInfo
           .whereIndexed((index, value) => mappings[index] != null)
           .map((c) => c.type)
           .toList(),
@@ -292,7 +293,7 @@ final class $ForGeneratedCode {
   }) => InsertSingle._(
     Insert._(
       table: table,
-      values: ExprValuesSource._(
+      values: ExprValuesSource.internal(
         table._tableClause.columns
             .whereIndexed((index, value) => values[index] != null)
             .toList(),
@@ -307,7 +308,7 @@ final class $ForGeneratedCode {
     UpdateSet<T> Function(Expr<T> row) updateBuilder,
   ) {
     final handle = Object();
-    final row = query._expressions.$1._standin(0, handle);
+    final row = query._expressions.$1.$standin(0, handle);
 
     return Update._(
       query,
@@ -325,7 +326,7 @@ final class $ForGeneratedCode {
     final q = query.asQuery;
 
     final handle = Object();
-    final row = q._expressions.$1._standin(0, handle);
+    final row = q._expressions.$1.$standin(0, handle);
 
     return UpdateSingle._(
       Update._(
@@ -354,7 +355,7 @@ final class $ForGeneratedCode {
     Expr<M> row,
     int index,
     FieldType<T> type,
-  ) => row._field(index, type);
+  ) => row.$field(index, type);
 
   static Query<S> renamedRecord<T extends Record, S extends Record>(
     Query<T> query,
@@ -371,8 +372,8 @@ final class $ForGeneratedCode {
     TableDefinition<T> table,
   ) {
     return SubQuery._(
-      (RowExpression._(0, table, Object()),),
-      (_) => TableClause._(table),
+      (RowExpression.internal(0, table, Object()),),
+      (_) => TableClause.internal(table),
     );
   }
 
@@ -389,17 +390,17 @@ final class $ForGeneratedCode {
   static CustomExprType<S, T> customDataType<S, T extends CustomDataType<S>>(
     ColumnType<S> backingType,
     T Function(S) fromDatabase,
-  ) => CustomExprType<S, T>._(backingType, fromDatabase);
+  ) => CustomExprType<S, T>.internal(backingType, fromDatabase);
 
   static Expr<T?> customDataTypeAsExpr<S, T extends CustomDataType<S>>(
     T? value,
     CustomExprType<S, T> type,
-  ) => ValueExpression<T?>._(value, type);
+  ) => ValueExpression<T?>.internal(value, type);
 
   static Expr<T?> customDataTypeAsExprLiteral<S, T extends CustomDataType<S>>(
     T? value,
     CustomExprType<S, T> type,
-  ) => LiteralExpression<T?>._(value, type);
+  ) => LiteralExpression<T?>.internal(value, type);
 
   static const ColumnType<Uint8List> blob = ColumnType.blob;
   static const ColumnType<bool> boolean = ColumnType.boolean;
diff --git a/typed_sql/lib/src/typed_sql.database.dart b/typed_sql/lib/src/typed_sql.database.dart
index 11cc3328..3921bc76 100644
--- a/typed_sql/lib/src/typed_sql.database.dart
+++ b/typed_sql/lib/src/typed_sql.database.dart
@@ -83,5 +83,5 @@ final class Database<T extends Schema> {
   /// This can be useful for evaluating multiple point-queries in a single
   /// database query.
   QuerySingle<S> select<S extends Record>(S expressions) =>
-      QuerySingle._(Query._(this, expressions, SelectClause._));
+      QuerySingle._(Query._(this, expressions, SelectClause.internal));
 }
diff --git a/typed_sql/lib/src/typed_sql.expr_ext.dart b/typed_sql/lib/src/typed_sql.expr_ext.dart
index 2ec12bba..277f5789 100644
--- a/typed_sql/lib/src/typed_sql.expr_ext.dart
+++ b/typed_sql/lib/src/typed_sql.expr_ext.dart
@@ -45,7 +45,9 @@ extension CustomTypeExt<S> on Expr<CustomDataType<S>> {
   /// Get an expression containing the encoded value of the [CustomDataType]
   /// implementation.
   Expr<S> asEncoded() =>
-      EncodedCustomDataTypeExpression<S, CustomDataType<S>>._(this).asNotNull();
+      EncodedCustomDataTypeExpression<S, CustomDataType<S>>.internal(
+        this,
+      ).asNotNull();
 }
 
 /// Extension methods for accessing the encoded value of a custom data type
@@ -53,7 +55,7 @@ extension CustomTypeExt<S> on Expr<CustomDataType<S>> {
 extension CustomTypeNullableExt<S> on Expr<CustomDataType<S>?> {
   /// Get an expression containing the encoded value of the [CustomDataType]
   /// implementation.
-  Expr<S?> asEncoded() => EncodedCustomDataTypeExpression._(this);
+  Expr<S?> asEncoded() => EncodedCustomDataTypeExpression.internal(this);
 }
 
 /// Extension methods for wrapping an [int] as an expression.
@@ -168,42 +170,43 @@ extension ExpressionNull on Expr<Null> {
   /// This method is rarely necessary, as you can generally pass `toExpr(null)`
   /// to any method expecting an `Expr<int?>`. But in some complex scenarios
   /// this can alleviate type inference issues.
-  Expr<int?> asInt() => CastExpression._(this, ColumnType.integer);
+  Expr<int?> asInt() => CastExpression.internal(this, ColumnType.integer);
 
   /// Cast as [Expr<String?>] using `CAST(NULL AS TEXT)`.
   ///
   /// This method is rarely necessary, as you can generally pass `toExpr(null)`
   /// to any method expecting an `Expr<String?>`. But in some complex scenarios
   /// this can alleviate type inference issues.
-  Expr<String?> asString() => CastExpression._(this, ColumnType.text);
+  Expr<String?> asString() => CastExpression.internal(this, ColumnType.text);
 
   /// Cast as [Expr<double?>] using `CAST(NULL AS DOUBLE PRECISION)`.
   ///
   /// This method is rarely necessary, as you can generally pass `toExpr(null)`
   /// to any method expecting an `Expr<double?>`. But in some complex scenarios
   /// this can alleviate type inference issues.
-  Expr<double?> asDouble() => CastExpression._(this, ColumnType.real);
+  Expr<double?> asDouble() => CastExpression.internal(this, ColumnType.real);
 
   /// Cast as [Expr<bool?>] using `CAST(NULL AS BOOLEAN)`.
   ///
   /// This method is rarely necessary, as you can generally pass `toExpr(null)`
   /// to any method expecting an `Expr<bool?>`. But in some complex scenarios
   /// this can alleviate type inference issues.
-  Expr<bool?> asBool() => CastExpression._(this, ColumnType.boolean);
+  Expr<bool?> asBool() => CastExpression.internal(this, ColumnType.boolean);
 
   /// Cast as [Expr<DateTime?>] using `CAST(NULL AS TIMESTAMP)`.
   ///
   /// This method is rarely necessary, as you can generally pass `toExpr(null)`
   /// to any method expecting an `Expr<DateTime?>`. But in some complex scenarios
   /// this can alleviate type inference issues.
-  Expr<DateTime?> asDateTime() => CastExpression._(this, ColumnType.dateTime);
+  Expr<DateTime?> asDateTime() =>
+      CastExpression.internal(this, ColumnType.dateTime);
 
   /// Cast as [Expr<Uint8List?>] using `CAST(NULL AS BLOB)`.
   ///
   /// This method is rarely necessary, as you can generally pass `toExpr(null)`
   /// to any method expecting an `Expr<Uint8List?>`. But in some complex scenarios
   /// this can alleviate type inference issues.
-  Expr<Uint8List?> asBlob() => CastExpression._(this, ColumnType.blob);
+  Expr<Uint8List?> asBlob() => CastExpression.internal(this, ColumnType.blob);
 
   /// Cast as [Expr<JsonValue?>] using `CAST(NULL AS JSONB)`.
   ///
@@ -211,7 +214,7 @@ extension ExpressionNull on Expr<Null> {
   /// to any method expecting an `Expr<JsonValue?>`. But in some complex scenarios
   /// this can alleviate type inference issues.
   Expr<JsonValue?> asJsonValue() =>
-      CastExpression._(this, ColumnType.jsonValue);
+      CastExpression.internal(this, ColumnType.jsonValue);
 
   // TODO: Generate cast for CustomDataType!
 }
@@ -230,7 +233,7 @@ extension ExpressionNullable<T> on Expr<T?> {
   /// > This is a no-op in SQL, there is no enforcement. This merely casts the
   /// > current expression to a non-nullable expression and does not cause an
   /// > error if the assertion is violated.
-  Expr<T> asNotNull() => NotNullExpression._(this);
+  Expr<T> asNotNull() => NotNullExpression.internal(this);
 }
 
 /// Extension methods for nullable [int] and [double] expressions.
@@ -240,7 +243,7 @@ extension ExpressionNullableNum<T extends num> on Expr<T?> {
   ///
   /// This is equivalent to `COALESCE(this, value)`.
   /// {@endtemplate}
-  Expr<T> orElse(Expr<T> value) => OrElseExpression._(this, value);
+  Expr<T> orElse(Expr<T> value) => OrElseExpression.internal(this, value);
 
   /// {@macro orElse}
   Expr<T> orElseValue(T value) => orElse(toExpr(value));
@@ -289,7 +292,8 @@ extension ExpressionNullableNum<T extends num> on Expr<T?> {
 /// Extension methods for nullable [String] expressions.
 extension ExpressionNullableString on Expr<String?> {
   /// {@macro orElse}
-  Expr<String> orElse(Expr<String> value) => OrElseExpression._(this, value);
+  Expr<String> orElse(Expr<String> value) =>
+      OrElseExpression.internal(this, value);
 
   /// {@macro orElse}
   Expr<String> orElseValue(String value) => orElse(toExpr(value));
@@ -318,7 +322,7 @@ extension ExpressionNullableString on Expr<String?> {
 /// Extension methods for nullable [bool] expressions.
 extension ExpressionNullableBool on Expr<bool?> {
   /// {@macro orElse}
-  Expr<bool> orElse(Expr<bool> value) => OrElseExpression._(this, value);
+  Expr<bool> orElse(Expr<bool> value) => OrElseExpression.internal(this, value);
 
   /// {@macro orElse}
   Expr<bool> orElseValue(bool value) => orElse(toExpr(value));
@@ -408,7 +412,7 @@ extension ExpressionNullableBool on Expr<bool?> {
 extension ExpressionNullableDateTime on Expr<DateTime?> {
   /// {@macro orElse}
   Expr<DateTime> orElse(Expr<DateTime> value) =>
-      OrElseExpression._(this, value);
+      OrElseExpression.internal(this, value);
 
   /// {@macro orElse}
   Expr<DateTime> orElseValue(DateTime value) => orElse(toExpr(value));
@@ -438,7 +442,7 @@ extension ExpressionNullableDateTime on Expr<DateTime?> {
 extension ExpressionNullableUint8List on Expr<Uint8List?> {
   /// {@macro orElse}
   Expr<Uint8List> orElse(Expr<Uint8List> value) =>
-      OrElseExpression._(this, value);
+      OrElseExpression.internal(this, value);
 
   /// {@macro orElse}
   Expr<Uint8List> orElseValue(Uint8List value) => orElse(toExpr(value));
@@ -475,7 +479,7 @@ extension ExpressionNullableJsonValue on Expr<JsonValue?> {
   /// > If `this` is an `JsonValue(null)`, then `this` will be returned.
   /// {@endtemplate}
   Expr<JsonValue> orElse(Expr<JsonValue> value) =>
-      OrElseExpression._(this, value);
+      OrElseExpression.internal(this, value);
 
   /// {@macro orElse}
   /// {@macro orElse-not-json-null}
@@ -510,10 +514,10 @@ extension ExpressionNullableJsonValue on Expr<JsonValue?> {
   /// ```sql
   /// this -> key
   /// ```
-  Expr<JsonValue?> field(String key) => ExpressionJsonRefKey._(
+  Expr<JsonValue?> field(String key) => ExpressionJsonRefKey.internal(
     this is ExpressionJsonRef
         ? this as ExpressionJsonRef
-        : ExpressionJsonRefRoot._(this),
+        : ExpressionJsonRefRoot.internal(this),
     key,
   );
 
@@ -530,10 +534,10 @@ extension ExpressionNullableJsonValue on Expr<JsonValue?> {
   /// ```sql
   /// this -> index
   /// ```
-  Expr<JsonValue?> elementAt(int index) => ExpressionJsonRefIndex._(
+  Expr<JsonValue?> elementAt(int index) => ExpressionJsonRefIndex.internal(
     this is ExpressionJsonRef
         ? this as ExpressionJsonRef
-        : ExpressionJsonRefRoot._(this),
+        : ExpressionJsonRefRoot.internal(this),
     index,
   );
 
@@ -553,12 +557,12 @@ extension ExpressionNullableJsonValue on Expr<JsonValue?> {
   Expr<JsonValue?> operator [](Object keyOrIndex) {
     final ref = this is ExpressionJsonRef
         ? this as ExpressionJsonRef
-        : ExpressionJsonRefRoot._(this);
+        : ExpressionJsonRefRoot.internal(this);
 
     if (keyOrIndex is String) {
-      return ExpressionJsonRefKey._(ref, keyOrIndex);
+      return ExpressionJsonRefKey.internal(ref, keyOrIndex);
     } else if (keyOrIndex is int) {
-      return ExpressionJsonRefIndex._(ref, keyOrIndex);
+      return ExpressionJsonRefIndex.internal(ref, keyOrIndex);
     }
     throw ArgumentError.value(
       keyOrIndex,
@@ -600,8 +604,10 @@ extension ExpressionNullableJsonValue on Expr<JsonValue?> {
   /// > If the JSON data does not match your expectations, the cast may cause
   /// > runtime failures or silently return unexpected values (like `0`).
   /// {@endtemplate}
-  Expr<int?> asInt() =>
-      CastExpression._(ExpressionJsonExtract._(this), ColumnType.integer);
+  Expr<int?> asInt() => CastExpression.internal(
+    ExpressionJsonExtract.internal(this),
+    ColumnType.integer,
+  );
 
   /// Extract the value as unquoted text.
   ///
@@ -614,8 +620,10 @@ extension ExpressionNullableJsonValue on Expr<JsonValue?> {
   /// ```
   ///
   /// {@macro json-extraction-behavior}
-  Expr<String?> asString() =>
-      CastExpression._(ExpressionJsonExtract._(this), ColumnType.text);
+  Expr<String?> asString() => CastExpression.internal(
+    ExpressionJsonExtract.internal(this),
+    ColumnType.text,
+  );
 
   /// Extract the value as unquoted text and cast it to a double.
   ///
@@ -635,8 +643,10 @@ extension ExpressionNullableJsonValue on Expr<JsonValue?> {
   /// * **SQLite:** Parses the numeric prefix of the string (e.g. `"3.14abc"` becomes `3.14`). Returns `0.0` if no valid prefix exists.
   ///
   /// {@macro unsafe-json-cast}
-  Expr<double?> asDouble() =>
-      CastExpression._(ExpressionJsonExtract._(this), ColumnType.real);
+  Expr<double?> asDouble() => CastExpression.internal(
+    ExpressionJsonExtract.internal(this),
+    ColumnType.real,
+  );
 
   /// Extract the value as unquoted text and cast it to a boolean.
   ///
@@ -656,8 +666,10 @@ extension ExpressionNullableJsonValue on Expr<JsonValue?> {
   /// * **SQLite:** Returns `TRUE` if the text is `true`, otherwise `FALSE`.
   ///
   /// {@macro unsafe-json-cast}
-  Expr<bool?> asBool() =>
-      CastExpression._(ExpressionJsonExtract._(this), ColumnType.boolean);
+  Expr<bool?> asBool() => CastExpression.internal(
+    ExpressionJsonExtract.internal(this),
+    ColumnType.boolean,
+  );
 }
 
 /// Extension methods for [bool] expressions.
@@ -738,7 +750,7 @@ extension ExpressionBool on Expr<bool> {
   /// {@endtemplate}
   /// @nodoc
   @Deprecated(_orElseOnNonNullableDeprecation)
-  Expr<bool> orElse(Expr<bool> value) => OrElseExpression._(this, value);
+  Expr<bool> orElse(Expr<bool> value) => OrElseExpression.internal(this, value);
 
   /// {@macro orElse}
   ///
@@ -813,7 +825,7 @@ extension ExpressionBool on Expr<bool> {
   /// Results:
   /// * `true` -> `1`
   /// * `false` -> `0`
-  Expr<int> asInt() => CastExpression._(this, ColumnType.integer);
+  Expr<int> asInt() => CastExpression.internal(this, ColumnType.integer);
   // Remark we could support casting to double it works, but requires an extra
   // step in postgres. It's not really a sensible thing to do. Should you ever
   // find it useful, just use `.asInt().asDouble()`.
@@ -854,7 +866,8 @@ extension ExpressionString on Expr<String> {
   /// {@macro orElse-non-nullable-deprecation}
   /// @nodoc
   @Deprecated(_orElseOnNonNullableDeprecation)
-  Expr<String> orElse(Expr<String> value) => OrElseExpression._(this, value);
+  Expr<String> orElse(Expr<String> value) =>
+      OrElseExpression.internal(this, value);
 
   /// {@macro orElse}
   ///
@@ -1037,7 +1050,7 @@ extension ExpressionString on Expr<String> {
   ///
   /// Example:
   /// * `'123'` -> `123`
-  Expr<int> asInt() => CastExpression._(this, ColumnType.integer);
+  Expr<int> asInt() => CastExpression.internal(this, ColumnType.integer);
 
   /// Cast as double.
   ///
@@ -1051,7 +1064,7 @@ extension ExpressionString on Expr<String> {
   ///
   /// Example:
   /// * `'3.14'` -> `3.14`
-  Expr<double> asDouble() => CastExpression._(this, ColumnType.real);
+  Expr<double> asDouble() => CastExpression.internal(this, ColumnType.real);
 }
 
 /// Extension methods for [int] expressions.
@@ -1143,7 +1156,7 @@ extension ExpressionInt on Expr<int> {
   ///
   /// Example:
   /// * `12345` -> `'12345'`
-  Expr<String> asString() => CastExpression._(this, ColumnType.text);
+  Expr<String> asString() => CastExpression.internal(this, ColumnType.text);
 
   /// Cast as double.
   ///
@@ -1154,7 +1167,7 @@ extension ExpressionInt on Expr<int> {
   ///
   /// Example:
   /// * `123` -> `123.0`
-  Expr<double> asDouble() => CastExpression._(this, ColumnType.real);
+  Expr<double> asDouble() => CastExpression.internal(this, ColumnType.real);
 }
 
 /// Extension methods for [double] expressions.
@@ -1219,7 +1232,7 @@ extension ExpressionDouble on Expr<double> {
   ///
   /// Example:
   /// * `3.14` -> `'3.14'`
-  Expr<String> asString() => CastExpression._(this, ColumnType.text);
+  Expr<String> asString() => CastExpression.internal(this, ColumnType.text);
 
   /// Cast as integer.
   ///
@@ -1230,7 +1243,7 @@ extension ExpressionDouble on Expr<double> {
   ///
   /// Example:
   /// * `3.14` -> `3`
-  Expr<int> asInt() => CastExpression._(this, ColumnType.integer);
+  Expr<int> asInt() => CastExpression.internal(this, ColumnType.integer);
 }
 
 /// Extension methods for [int] and [double] expressions.
@@ -1267,7 +1280,7 @@ extension ExpressionNum<T extends num> on Expr<T> {
   /// {@macro orElse-non-nullable-deprecation}
   /// @nodoc
   @Deprecated(_orElseOnNonNullableDeprecation)
-  Expr<T> orElse(Expr<T> value) => OrElseExpression._(this, value);
+  Expr<T> orElse(Expr<T> value) => OrElseExpression.internal(this, value);
 
   /// {@macro orElse}
   ///
@@ -1356,7 +1369,7 @@ extension ExpressionDateTime on Expr<DateTime> {
   /// @nodoc
   @Deprecated(_orElseOnNonNullableDeprecation)
   Expr<DateTime> orElse(Expr<DateTime> value) =>
-      OrElseExpression._(this, value);
+      OrElseExpression.internal(this, value);
 
   /// {@macro orElse}
   ///
@@ -1446,7 +1459,7 @@ extension ExpressionUint8List on Expr<Uint8List> {
   /// @nodoc
   @Deprecated(_orElseOnNonNullableDeprecation)
   Expr<Uint8List> orElse(Expr<Uint8List> value) =>
-      OrElseExpression._(this, value);
+      OrElseExpression.internal(this, value);
 
   /// {@macro orElse}
   ///
@@ -1501,7 +1514,7 @@ extension ExpressionJsonValue on Expr<JsonValue> {
   /// @nodoc
   @Deprecated(_orElseOnNonNullableDeprecation)
   Expr<JsonValue> orElse(Expr<JsonValue> value) =>
-      OrElseExpression._(this, value);
+      OrElseExpression.internal(this, value);
 
   /// {@macro orElse}
   ///
diff --git a/typed_sql/lib/src/typed_sql.g.dart b/typed_sql/lib/src/typed_sql.g.dart
index 64453dc1..03910486 100644
--- a/typed_sql/lib/src/typed_sql.g.dart
+++ b/typed_sql/lib/src/typed_sql.g.dart
@@ -12,7 +12,7 @@ extension Query1<A> on Query<(Expr<A>,)> {
   (Object, T) _build<T>(T Function(Expr<A> a) builder) {
     final handle = Object();
     var offset = 0;
-    final a = _expressions.$1._standin(offset, handle);
+    final a = _expressions.$1.$standin(offset, handle);
     return (handle, builder(a));
   }
 
@@ -25,7 +25,7 @@ extension Query1<A> on Query<(Expr<A>,)> {
     return Query._(
       _context,
       _expressions,
-      (e) => WhereClause._(_from(e), handle, where),
+      (e) => WhereClause.internal(_from(e), handle, where),
     );
   }
 
@@ -64,7 +64,7 @@ extension Query1<A> on Query<(Expr<A>,)> {
       Query._(
         _context,
         _expressions,
-        (e) => OrderByClause._(_from(e), handle, orderBy),
+        (e) => OrderByClause.internal(_from(e), handle, orderBy),
       ),
     );
   }
@@ -72,14 +72,20 @@ extension Query1<A> on Query<(Expr<A>,)> {
   /// Limit [Query] using `LIMIT` clause.
   ///
   /// The resulting [Query] will only return the first [limit] rows.
-  Query<(Expr<A>,)> limit(int limit) =>
-      Query._(_context, _expressions, (e) => LimitClause._(_from(e), limit));
+  Query<(Expr<A>,)> limit(int limit) => Query._(
+    _context,
+    _expressions,
+    (e) => LimitClause.internal(_from(e), limit),
+  );
 
   /// Offset [Query] using `OFFSET` clause.
   ///
   /// The resulting [Query] will skip the first [offset] rows.
-  Query<(Expr<A>,)> offset(int offset) =>
-      Query._(_context, _expressions, (e) => OffsetClause._(_from(e), offset));
+  Query<(Expr<A>,)> offset(int offset) => Query._(
+    _context,
+    _expressions,
+    (e) => OffsetClause.internal(_from(e), offset),
+  );
 
   /// Limit [Query] to the first row using `LIMIT` clause.
   ///
@@ -96,7 +102,7 @@ extension Query1<A> on Query<(Expr<A>,)> {
   /// don't wish to count `null` values, use [where] to filter out such
   /// rows first.
   QuerySingle<(Expr<int>,)> count() =>
-      select((a) => (CountAllExpression._(),)).first;
+      select((a) => (CountAllExpression.internal(),)).first;
 
   /// Create a projection of this [Query] using `SELECT` clause.
   ///
@@ -112,7 +118,7 @@ extension Query1<A> on Query<(Expr<A>,)> {
     return Query._(
       _context,
       projection,
-      (e) => SelectFromClause._(_from(_expressions.toList()), handle, e),
+      (e) => SelectFromClause.internal(_from(_expressions.toList()), handle, e),
     );
   }
 
@@ -158,20 +164,24 @@ extension Query1<A> on Query<(Expr<A>,)> {
   /// > using `.asSubQuery.exists()` which returns an [Expr<bool>].
   QuerySingle<(Expr<bool>,)> exists() => QuerySingle._(
     Query._(_context, (
-      ExistsExpression._(_from(_expressions.toList())),
-    ), SelectClause._),
+      ExistsExpression.internal(_from(_expressions.toList())),
+    ), SelectClause.internal),
   );
 
   QueryClause _castAs(Query<(Expr<A>,)> as) {
     final (handle, projection) = _build(
       (a) => [
-        if (a._type is _ExprType<Null>)
-          ..._NullExprType._explodedCastAs(a, as._expressions.$1._type)
+        if (identical(a.$exprType, ColumnType.nullType))
+          ...explodedCastAs(a, as._expressions.$1.$exprType)
         else
           a,
       ],
     );
-    return SelectFromClause._(_from(_expressions.toList()), handle, projection);
+    return SelectFromClause.internal(
+      _from(_expressions.toList()),
+      handle,
+      projection,
+    );
   }
 
   /// Combine this [Query] with [other] using `UNION` _set operator_.
@@ -181,7 +191,8 @@ extension Query1<A> on Query<(Expr<A>,)> {
   Query<(Expr<A>,)> union(Query<(Expr<A>,)> other) => Query._(
     _context,
     _expressions,
-    (e) => UnionClause._(_from(_expressions.toList()), other._castAs(this)),
+    (e) =>
+        UnionClause.internal(_from(_expressions.toList()), other._castAs(this)),
   );
 
   /// Combine this [Query] with [other] using `UNION ALL` _set operator_.
@@ -191,7 +202,10 @@ extension Query1<A> on Query<(Expr<A>,)> {
   Query<(Expr<A>,)> unionAll(Query<(Expr<A>,)> other) => Query._(
     _context,
     _expressions,
-    (e) => UnionAllClause._(_from(_expressions.toList()), other._castAs(this)),
+    (e) => UnionAllClause.internal(
+      _from(_expressions.toList()),
+      other._castAs(this),
+    ),
   );
 
   /// Combine this [Query] with [other] using `INTERSECT` _set operator_.
@@ -201,7 +215,10 @@ extension Query1<A> on Query<(Expr<A>,)> {
   Query<(Expr<A>,)> intersect(Query<(Expr<A>,)> other) => Query._(
     _context,
     _expressions,
-    (e) => IntersectClause._(_from(_expressions.toList()), other._castAs(this)),
+    (e) => IntersectClause.internal(
+      _from(_expressions.toList()),
+      other._castAs(this),
+    ),
   );
 
   /// Combine this [Query] with [other] using `EXCEPT` _set operator_.
@@ -212,7 +229,10 @@ extension Query1<A> on Query<(Expr<A>,)> {
   Query<(Expr<A>,)> except(Query<(Expr<A>,)> other) => Query._(
     _context,
     _expressions,
-    (e) => ExceptClause._(_from(_expressions.toList()), other._castAs(this)),
+    (e) => ExceptClause.internal(
+      _from(_expressions.toList()),
+      other._castAs(this),
+    ),
   );
 
   /// Combine this [Query] with [other] using `UNION` _set operator_.
@@ -262,8 +282,8 @@ extension Query1<A> on Query<(Expr<A>,)> {
   /// Query the database for rows in this [Query] as a [Stream].
   Stream<A> stream() async* {
     final from = _from(_expressions.toList());
-    final decode1 = _expressions.$1._decode;
-    final task = _context._dialect.select(SelectStatement._(from));
+    final decode1 = _expressions.$1.$decode;
+    final task = _context._dialect.select(SelectStatement.internal(from));
     await for (final row in _context._query(task)) {
       yield decode1(row) as A;
     }
@@ -279,7 +299,7 @@ extension SubQuery1<A> on SubQuery<(Expr<A>,)> {
   (Object, T) _build<T>(T Function(Expr<A> a) builder) {
     final handle = Object();
     var offset = 0;
-    final a = _expressions.$1._standin(offset, handle);
+    final a = _expressions.$1.$standin(offset, handle);
     return (handle, builder(a));
   }
 
@@ -291,7 +311,7 @@ extension SubQuery1<A> on SubQuery<(Expr<A>,)> {
     final (handle, where) = _build(conditionBuilder);
     return SubQuery._(
       _expressions,
-      (e) => WhereClause._(_from(e), handle, where),
+      (e) => WhereClause.internal(_from(e), handle, where),
     );
   }
 
@@ -329,7 +349,7 @@ extension SubQuery1<A> on SubQuery<(Expr<A>,)> {
     return OrderedSubQuery._(
       SubQuery._(
         _expressions,
-        (e) => OrderByClause._(_from(e), handle, orderBy),
+        (e) => OrderByClause.internal(_from(e), handle, orderBy),
       ),
     );
   }
@@ -338,13 +358,13 @@ extension SubQuery1<A> on SubQuery<(Expr<A>,)> {
   ///
   /// The resulting [SubQuery] will only return the first [limit] rows.
   SubQuery<(Expr<A>,)> limit(int limit) =>
-      SubQuery._(_expressions, (e) => LimitClause._(_from(e), limit));
+      SubQuery._(_expressions, (e) => LimitClause.internal(_from(e), limit));
 
   /// Offset [SubQuery] using `OFFSET` clause.
   ///
   /// The resulting [SubQuery] will skip the first [offset] rows.
   SubQuery<(Expr<A>,)> offset(int offset) =>
-      SubQuery._(_expressions, (e) => OffsetClause._(_from(e), offset));
+      SubQuery._(_expressions, (e) => OffsetClause.internal(_from(e), offset));
 
   /// Count number of rows in this [SubQuery] using `COUNT(*)` aggregate
   /// function.
@@ -356,7 +376,7 @@ extension SubQuery1<A> on SubQuery<(Expr<A>,)> {
   /// don't wish to count `null` values, use [where] to filter out such
   /// rows first.
   Expr<int> count() =>
-      select((a) => (CountAllExpression._(),)).first.asNotNull();
+      select((a) => (CountAllExpression.internal(),)).first.asNotNull();
 
   /// Create a projection of this [SubQuery] using `SELECT` clause.
   ///
@@ -373,7 +393,7 @@ extension SubQuery1<A> on SubQuery<(Expr<A>,)> {
     final (handle, projection) = _build(projectionBuilder);
     return SubQuery._(
       projection,
-      (e) => SelectFromClause._(_from(_expressions.toList()), handle, e),
+      (e) => SelectFromClause.internal(_from(_expressions.toList()), handle, e),
     );
   }
 
@@ -381,7 +401,8 @@ extension SubQuery1<A> on SubQuery<(Expr<A>,)> {
   ///
   /// This returns an [Expr<bool>] that evaluates to `true`, if this [SubQuery]
   /// contains any rows, even if those rows are entirely `null`s.
-  Expr<bool> exists() => ExistsExpression._(_from(_expressions.toList()));
+  Expr<bool> exists() =>
+      ExistsExpression.internal(_from(_expressions.toList()));
 }
 
 /// Extension methods for a query returning zero or more rows with
@@ -856,9 +877,9 @@ extension Query2<A, B> on Query<(Expr<A>, Expr<B>)> {
   (Object, T) _build<T>(T Function(Expr<A> a, Expr<B> b) builder) {
     final handle = Object();
     var offset = 0;
-    final a = _expressions.$1._standin(offset, handle);
-    offset += _expressions.$1._columns;
-    final b = _expressions.$2._standin(offset, handle);
+    final a = _expressions.$1.$standin(offset, handle);
+    offset += _expressions.$1.$columnCount;
+    final b = _expressions.$2.$standin(offset, handle);
     return (handle, builder(a, b));
   }
 
@@ -873,7 +894,7 @@ extension Query2<A, B> on Query<(Expr<A>, Expr<B>)> {
     return Query._(
       _context,
       _expressions,
-      (e) => WhereClause._(_from(e), handle, where),
+      (e) => WhereClause.internal(_from(e), handle, where),
     );
   }
 
@@ -912,7 +933,7 @@ extension Query2<A, B> on Query<(Expr<A>, Expr<B>)> {
       Query._(
         _context,
         _expressions,
-        (e) => OrderByClause._(_from(e), handle, orderBy),
+        (e) => OrderByClause.internal(_from(e), handle, orderBy),
       ),
     );
   }
@@ -920,14 +941,20 @@ extension Query2<A, B> on Query<(Expr<A>, Expr<B>)> {
   /// Limit [Query] using `LIMIT` clause.
   ///
   /// The resulting [Query] will only return the first [limit] rows.
-  Query<(Expr<A>, Expr<B>)> limit(int limit) =>
-      Query._(_context, _expressions, (e) => LimitClause._(_from(e), limit));
+  Query<(Expr<A>, Expr<B>)> limit(int limit) => Query._(
+    _context,
+    _expressions,
+    (e) => LimitClause.internal(_from(e), limit),
+  );
 
   /// Offset [Query] using `OFFSET` clause.
   ///
   /// The resulting [Query] will skip the first [offset] rows.
-  Query<(Expr<A>, Expr<B>)> offset(int offset) =>
-      Query._(_context, _expressions, (e) => OffsetClause._(_from(e), offset));
+  Query<(Expr<A>, Expr<B>)> offset(int offset) => Query._(
+    _context,
+    _expressions,
+    (e) => OffsetClause.internal(_from(e), offset),
+  );
 
   /// Limit [Query] to the first row using `LIMIT` clause.
   ///
@@ -944,7 +971,7 @@ extension Query2<A, B> on Query<(Expr<A>, Expr<B>)> {
   /// don't wish to count `null` values, use [where] to filter out such
   /// rows first.
   QuerySingle<(Expr<int>,)> count() =>
-      select((a, b) => (CountAllExpression._(),)).first;
+      select((a, b) => (CountAllExpression.internal(),)).first;
 
   /// Create a projection of this [Query] using `SELECT` clause.
   ///
@@ -962,7 +989,7 @@ extension Query2<A, B> on Query<(Expr<A>, Expr<B>)> {
     return Query._(
       _context,
       projection,
-      (e) => SelectFromClause._(_from(_expressions.toList()), handle, e),
+      (e) => SelectFromClause.internal(_from(_expressions.toList()), handle, e),
     );
   }
 
@@ -1009,24 +1036,28 @@ extension Query2<A, B> on Query<(Expr<A>, Expr<B>)> {
   /// > using `.asSubQuery.exists()` which returns an [Expr<bool>].
   QuerySingle<(Expr<bool>,)> exists() => QuerySingle._(
     Query._(_context, (
-      ExistsExpression._(_from(_expressions.toList())),
-    ), SelectClause._),
+      ExistsExpression.internal(_from(_expressions.toList())),
+    ), SelectClause.internal),
   );
 
   QueryClause _castAs(Query<(Expr<A>, Expr<B>)> as) {
     final (handle, projection) = _build(
       (a, b) => [
-        if (a._type is _ExprType<Null>)
-          ..._NullExprType._explodedCastAs(a, as._expressions.$1._type)
+        if (identical(a.$exprType, ColumnType.nullType))
+          ...explodedCastAs(a, as._expressions.$1.$exprType)
         else
           a,
-        if (b._type is _ExprType<Null>)
-          ..._NullExprType._explodedCastAs(b, as._expressions.$2._type)
+        if (identical(b.$exprType, ColumnType.nullType))
+          ...explodedCastAs(b, as._expressions.$2.$exprType)
         else
           b,
       ],
     );
-    return SelectFromClause._(_from(_expressions.toList()), handle, projection);
+    return SelectFromClause.internal(
+      _from(_expressions.toList()),
+      handle,
+      projection,
+    );
   }
 
   /// Combine this [Query] with [other] using `UNION` _set operator_.
@@ -1036,7 +1067,8 @@ extension Query2<A, B> on Query<(Expr<A>, Expr<B>)> {
   Query<(Expr<A>, Expr<B>)> union(Query<(Expr<A>, Expr<B>)> other) => Query._(
     _context,
     _expressions,
-    (e) => UnionClause._(_from(_expressions.toList()), other._castAs(this)),
+    (e) =>
+        UnionClause.internal(_from(_expressions.toList()), other._castAs(this)),
   );
 
   /// Combine this [Query] with [other] using `UNION ALL` _set operator_.
@@ -1047,8 +1079,10 @@ extension Query2<A, B> on Query<(Expr<A>, Expr<B>)> {
       Query._(
         _context,
         _expressions,
-        (e) =>
-            UnionAllClause._(_from(_expressions.toList()), other._castAs(this)),
+        (e) => UnionAllClause.internal(
+          _from(_expressions.toList()),
+          other._castAs(this),
+        ),
       );
 
   /// Combine this [Query] with [other] using `INTERSECT` _set operator_.
@@ -1059,7 +1093,7 @@ extension Query2<A, B> on Query<(Expr<A>, Expr<B>)> {
       Query._(
         _context,
         _expressions,
-        (e) => IntersectClause._(
+        (e) => IntersectClause.internal(
           _from(_expressions.toList()),
           other._castAs(this),
         ),
@@ -1073,7 +1107,10 @@ extension Query2<A, B> on Query<(Expr<A>, Expr<B>)> {
   Query<(Expr<A>, Expr<B>)> except(Query<(Expr<A>, Expr<B>)> other) => Query._(
     _context,
     _expressions,
-    (e) => ExceptClause._(_from(_expressions.toList()), other._castAs(this)),
+    (e) => ExceptClause.internal(
+      _from(_expressions.toList()),
+      other._castAs(this),
+    ),
   );
 
   /// Combine this [Query] with [other] using `UNION` _set operator_.
@@ -1127,9 +1164,9 @@ extension Query2<A, B> on Query<(Expr<A>, Expr<B>)> {
   /// Query the database for rows in this [Query] as a [Stream].
   Stream<(A, B)> stream() async* {
     final from = _from(_expressions.toList());
-    final decode1 = _expressions.$1._decode;
-    final decode2 = _expressions.$2._decode;
-    final task = _context._dialect.select(SelectStatement._(from));
+    final decode1 = _expressions.$1.$decode;
+    final decode2 = _expressions.$2.$decode;
+    final task = _context._dialect.select(SelectStatement.internal(from));
     await for (final row in _context._query(task)) {
       yield (decode1(row) as A, decode2(row) as B);
     }
@@ -1145,9 +1182,9 @@ extension SubQuery2<A, B> on SubQuery<(Expr<A>, Expr<B>)> {
   (Object, T) _build<T>(T Function(Expr<A> a, Expr<B> b) builder) {
     final handle = Object();
     var offset = 0;
-    final a = _expressions.$1._standin(offset, handle);
-    offset += _expressions.$1._columns;
-    final b = _expressions.$2._standin(offset, handle);
+    final a = _expressions.$1.$standin(offset, handle);
+    offset += _expressions.$1.$columnCount;
+    final b = _expressions.$2.$standin(offset, handle);
     return (handle, builder(a, b));
   }
 
@@ -1161,7 +1198,7 @@ extension SubQuery2<A, B> on SubQuery<(Expr<A>, Expr<B>)> {
     final (handle, where) = _build(conditionBuilder);
     return SubQuery._(
       _expressions,
-      (e) => WhereClause._(_from(e), handle, where),
+      (e) => WhereClause.internal(_from(e), handle, where),
     );
   }
 
@@ -1199,7 +1236,7 @@ extension SubQuery2<A, B> on SubQuery<(Expr<A>, Expr<B>)> {
     return OrderedSubQuery._(
       SubQuery._(
         _expressions,
-        (e) => OrderByClause._(_from(e), handle, orderBy),
+        (e) => OrderByClause.internal(_from(e), handle, orderBy),
       ),
     );
   }
@@ -1208,13 +1245,13 @@ extension SubQuery2<A, B> on SubQuery<(Expr<A>, Expr<B>)> {
   ///
   /// The resulting [SubQuery] will only return the first [limit] rows.
   SubQuery<(Expr<A>, Expr<B>)> limit(int limit) =>
-      SubQuery._(_expressions, (e) => LimitClause._(_from(e), limit));
+      SubQuery._(_expressions, (e) => LimitClause.internal(_from(e), limit));
 
   /// Offset [SubQuery] using `OFFSET` clause.
   ///
   /// The resulting [SubQuery] will skip the first [offset] rows.
   SubQuery<(Expr<A>, Expr<B>)> offset(int offset) =>
-      SubQuery._(_expressions, (e) => OffsetClause._(_from(e), offset));
+      SubQuery._(_expressions, (e) => OffsetClause.internal(_from(e), offset));
 
   /// Count number of rows in this [SubQuery] using `COUNT(*)` aggregate
   /// function.
@@ -1226,7 +1263,7 @@ extension SubQuery2<A, B> on SubQuery<(Expr<A>, Expr<B>)> {
   /// don't wish to count `null` values, use [where] to filter out such
   /// rows first.
   Expr<int> count() =>
-      select((a, b) => (CountAllExpression._(),)).first.asNotNull();
+      select((a, b) => (CountAllExpression.internal(),)).first.asNotNull();
 
   /// Create a projection of this [SubQuery] using `SELECT` clause.
   ///
@@ -1243,7 +1280,7 @@ extension SubQuery2<A, B> on SubQuery<(Expr<A>, Expr<B>)> {
     final (handle, projection) = _build(projectionBuilder);
     return SubQuery._(
       projection,
-      (e) => SelectFromClause._(_from(_expressions.toList()), handle, e),
+      (e) => SelectFromClause.internal(_from(_expressions.toList()), handle, e),
     );
   }
 
@@ -1251,7 +1288,8 @@ extension SubQuery2<A, B> on SubQuery<(Expr<A>, Expr<B>)> {
   ///
   /// This returns an [Expr<bool>] that evaluates to `true`, if this [SubQuery]
   /// contains any rows, even if those rows are entirely `null`s.
-  Expr<bool> exists() => ExistsExpression._(_from(_expressions.toList()));
+  Expr<bool> exists() =>
+      ExistsExpression.internal(_from(_expressions.toList()));
 }
 
 /// Extension methods for a query returning zero or more rows with
@@ -1729,11 +1767,11 @@ extension Query3<A, B, C> on Query<(Expr<A>, Expr<B>, Expr<C>)> {
   (Object, T) _build<T>(T Function(Expr<A> a, Expr<B> b, Expr<C> c) builder) {
     final handle = Object();
     var offset = 0;
-    final a = _expressions.$1._standin(offset, handle);
-    offset += _expressions.$1._columns;
-    final b = _expressions.$2._standin(offset, handle);
-    offset += _expressions.$2._columns;
-    final c = _expressions.$3._standin(offset, handle);
+    final a = _expressions.$1.$standin(offset, handle);
+    offset += _expressions.$1.$columnCount;
+    final b = _expressions.$2.$standin(offset, handle);
+    offset += _expressions.$2.$columnCount;
+    final c = _expressions.$3.$standin(offset, handle);
     return (handle, builder(a, b, c));
   }
 
@@ -1748,7 +1786,7 @@ extension Query3<A, B, C> on Query<(Expr<A>, Expr<B>, Expr<C>)> {
     return Query._(
       _context,
       _expressions,
-      (e) => WhereClause._(_from(e), handle, where),
+      (e) => WhereClause.internal(_from(e), handle, where),
     );
   }
 
@@ -1788,7 +1826,7 @@ extension Query3<A, B, C> on Query<(Expr<A>, Expr<B>, Expr<C>)> {
       Query._(
         _context,
         _expressions,
-        (e) => OrderByClause._(_from(e), handle, orderBy),
+        (e) => OrderByClause.internal(_from(e), handle, orderBy),
       ),
     );
   }
@@ -1796,14 +1834,20 @@ extension Query3<A, B, C> on Query<(Expr<A>, Expr<B>, Expr<C>)> {
   /// Limit [Query] using `LIMIT` clause.
   ///
   /// The resulting [Query] will only return the first [limit] rows.
-  Query<(Expr<A>, Expr<B>, Expr<C>)> limit(int limit) =>
-      Query._(_context, _expressions, (e) => LimitClause._(_from(e), limit));
+  Query<(Expr<A>, Expr<B>, Expr<C>)> limit(int limit) => Query._(
+    _context,
+    _expressions,
+    (e) => LimitClause.internal(_from(e), limit),
+  );
 
   /// Offset [Query] using `OFFSET` clause.
   ///
   /// The resulting [Query] will skip the first [offset] rows.
-  Query<(Expr<A>, Expr<B>, Expr<C>)> offset(int offset) =>
-      Query._(_context, _expressions, (e) => OffsetClause._(_from(e), offset));
+  Query<(Expr<A>, Expr<B>, Expr<C>)> offset(int offset) => Query._(
+    _context,
+    _expressions,
+    (e) => OffsetClause.internal(_from(e), offset),
+  );
 
   /// Limit [Query] to the first row using `LIMIT` clause.
   ///
@@ -1820,7 +1864,7 @@ extension Query3<A, B, C> on Query<(Expr<A>, Expr<B>, Expr<C>)> {
   /// don't wish to count `null` values, use [where] to filter out such
   /// rows first.
   QuerySingle<(Expr<int>,)> count() =>
-      select((a, b, c) => (CountAllExpression._(),)).first;
+      select((a, b, c) => (CountAllExpression.internal(),)).first;
 
   /// Create a projection of this [Query] using `SELECT` clause.
   ///
@@ -1838,7 +1882,7 @@ extension Query3<A, B, C> on Query<(Expr<A>, Expr<B>, Expr<C>)> {
     return Query._(
       _context,
       projection,
-      (e) => SelectFromClause._(_from(_expressions.toList()), handle, e),
+      (e) => SelectFromClause.internal(_from(_expressions.toList()), handle, e),
     );
   }
 
@@ -1887,28 +1931,32 @@ extension Query3<A, B, C> on Query<(Expr<A>, Expr<B>, Expr<C>)> {
   /// > using `.asSubQuery.exists()` which returns an [Expr<bool>].
   QuerySingle<(Expr<bool>,)> exists() => QuerySingle._(
     Query._(_context, (
-      ExistsExpression._(_from(_expressions.toList())),
-    ), SelectClause._),
+      ExistsExpression.internal(_from(_expressions.toList())),
+    ), SelectClause.internal),
   );
 
   QueryClause _castAs(Query<(Expr<A>, Expr<B>, Expr<C>)> as) {
     final (handle, projection) = _build(
       (a, b, c) => [
-        if (a._type is _ExprType<Null>)
-          ..._NullExprType._explodedCastAs(a, as._expressions.$1._type)
+        if (identical(a.$exprType, ColumnType.nullType))
+          ...explodedCastAs(a, as._expressions.$1.$exprType)
         else
           a,
-        if (b._type is _ExprType<Null>)
-          ..._NullExprType._explodedCastAs(b, as._expressions.$2._type)
+        if (identical(b.$exprType, ColumnType.nullType))
+          ...explodedCastAs(b, as._expressions.$2.$exprType)
         else
           b,
-        if (c._type is _ExprType<Null>)
-          ..._NullExprType._explodedCastAs(c, as._expressions.$3._type)
+        if (identical(c.$exprType, ColumnType.nullType))
+          ...explodedCastAs(c, as._expressions.$3.$exprType)
         else
           c,
       ],
     );
-    return SelectFromClause._(_from(_expressions.toList()), handle, projection);
+    return SelectFromClause.internal(
+      _from(_expressions.toList()),
+      handle,
+      projection,
+    );
   }
 
   /// Combine this [Query] with [other] using `UNION` _set operator_.
@@ -1920,7 +1968,8 @@ extension Query3<A, B, C> on Query<(Expr<A>, Expr<B>, Expr<C>)> {
   ) => Query._(
     _context,
     _expressions,
-    (e) => UnionClause._(_from(_expressions.toList()), other._castAs(this)),
+    (e) =>
+        UnionClause.internal(_from(_expressions.toList()), other._castAs(this)),
   );
 
   /// Combine this [Query] with [other] using `UNION ALL` _set operator_.
@@ -1932,7 +1981,10 @@ extension Query3<A, B, C> on Query<(Expr<A>, Expr<B>, Expr<C>)> {
   ) => Query._(
     _context,
     _expressions,
-    (e) => UnionAllClause._(_from(_expressions.toList()), other._castAs(this)),
+    (e) => UnionAllClause.internal(
+      _from(_expressions.toList()),
+      other._castAs(this),
+    ),
   );
 
   /// Combine this [Query] with [other] using `INTERSECT` _set operator_.
@@ -1944,7 +1996,10 @@ extension Query3<A, B, C> on Query<(Expr<A>, Expr<B>, Expr<C>)> {
   ) => Query._(
     _context,
     _expressions,
-    (e) => IntersectClause._(_from(_expressions.toList()), other._castAs(this)),
+    (e) => IntersectClause.internal(
+      _from(_expressions.toList()),
+      other._castAs(this),
+    ),
   );
 
   /// Combine this [Query] with [other] using `EXCEPT` _set operator_.
@@ -1957,7 +2012,10 @@ extension Query3<A, B, C> on Query<(Expr<A>, Expr<B>, Expr<C>)> {
   ) => Query._(
     _context,
     _expressions,
-    (e) => ExceptClause._(_from(_expressions.toList()), other._castAs(this)),
+    (e) => ExceptClause.internal(
+      _from(_expressions.toList()),
+      other._castAs(this),
+    ),
   );
 
   /// Combine this [Query] with [other] using `UNION` _set operator_.
@@ -2015,10 +2073,10 @@ extension Query3<A, B, C> on Query<(Expr<A>, Expr<B>, Expr<C>)> {
   /// Query the database for rows in this [Query] as a [Stream].
   Stream<(A, B, C)> stream() async* {
     final from = _from(_expressions.toList());
-    final decode1 = _expressions.$1._decode;
-    final decode2 = _expressions.$2._decode;
-    final decode3 = _expressions.$3._decode;
-    final task = _context._dialect.select(SelectStatement._(from));
+    final decode1 = _expressions.$1.$decode;
+    final decode2 = _expressions.$2.$decode;
+    final decode3 = _expressions.$3.$decode;
+    final task = _context._dialect.select(SelectStatement.internal(from));
     await for (final row in _context._query(task)) {
       yield (decode1(row) as A, decode2(row) as B, decode3(row) as C);
     }
@@ -2034,11 +2092,11 @@ extension SubQuery3<A, B, C> on SubQuery<(Expr<A>, Expr<B>, Expr<C>)> {
   (Object, T) _build<T>(T Function(Expr<A> a, Expr<B> b, Expr<C> c) builder) {
     final handle = Object();
     var offset = 0;
-    final a = _expressions.$1._standin(offset, handle);
-    offset += _expressions.$1._columns;
-    final b = _expressions.$2._standin(offset, handle);
-    offset += _expressions.$2._columns;
-    final c = _expressions.$3._standin(offset, handle);
+    final a = _expressions.$1.$standin(offset, handle);
+    offset += _expressions.$1.$columnCount;
+    final b = _expressions.$2.$standin(offset, handle);
+    offset += _expressions.$2.$columnCount;
+    final c = _expressions.$3.$standin(offset, handle);
     return (handle, builder(a, b, c));
   }
 
@@ -2052,7 +2110,7 @@ extension SubQuery3<A, B, C> on SubQuery<(Expr<A>, Expr<B>, Expr<C>)> {
     final (handle, where) = _build(conditionBuilder);
     return SubQuery._(
       _expressions,
-      (e) => WhereClause._(_from(e), handle, where),
+      (e) => WhereClause.internal(_from(e), handle, where),
     );
   }
 
@@ -2091,7 +2149,7 @@ extension SubQuery3<A, B, C> on SubQuery<(Expr<A>, Expr<B>, Expr<C>)> {
     return OrderedSubQuery._(
       SubQuery._(
         _expressions,
-        (e) => OrderByClause._(_from(e), handle, orderBy),
+        (e) => OrderByClause.internal(_from(e), handle, orderBy),
       ),
     );
   }
@@ -2100,13 +2158,13 @@ extension SubQuery3<A, B, C> on SubQuery<(Expr<A>, Expr<B>, Expr<C>)> {
   ///
   /// The resulting [SubQuery] will only return the first [limit] rows.
   SubQuery<(Expr<A>, Expr<B>, Expr<C>)> limit(int limit) =>
-      SubQuery._(_expressions, (e) => LimitClause._(_from(e), limit));
+      SubQuery._(_expressions, (e) => LimitClause.internal(_from(e), limit));
 
   /// Offset [SubQuery] using `OFFSET` clause.
   ///
   /// The resulting [SubQuery] will skip the first [offset] rows.
   SubQuery<(Expr<A>, Expr<B>, Expr<C>)> offset(int offset) =>
-      SubQuery._(_expressions, (e) => OffsetClause._(_from(e), offset));
+      SubQuery._(_expressions, (e) => OffsetClause.internal(_from(e), offset));
 
   /// Count number of rows in this [SubQuery] using `COUNT(*)` aggregate
   /// function.
@@ -2118,7 +2176,7 @@ extension SubQuery3<A, B, C> on SubQuery<(Expr<A>, Expr<B>, Expr<C>)> {
   /// don't wish to count `null` values, use [where] to filter out such
   /// rows first.
   Expr<int> count() =>
-      select((a, b, c) => (CountAllExpression._(),)).first.asNotNull();
+      select((a, b, c) => (CountAllExpression.internal(),)).first.asNotNull();
 
   /// Create a projection of this [SubQuery] using `SELECT` clause.
   ///
@@ -2135,7 +2193,7 @@ extension SubQuery3<A, B, C> on SubQuery<(Expr<A>, Expr<B>, Expr<C>)> {
     final (handle, projection) = _build(projectionBuilder);
     return SubQuery._(
       projection,
-      (e) => SelectFromClause._(_from(_expressions.toList()), handle, e),
+      (e) => SelectFromClause.internal(_from(_expressions.toList()), handle, e),
     );
   }
 
@@ -2143,7 +2201,8 @@ extension SubQuery3<A, B, C> on SubQuery<(Expr<A>, Expr<B>, Expr<C>)> {
   ///
   /// This returns an [Expr<bool>] that evaluates to `true`, if this [SubQuery]
   /// contains any rows, even if those rows are entirely `null`s.
-  Expr<bool> exists() => ExistsExpression._(_from(_expressions.toList()));
+  Expr<bool> exists() =>
+      ExistsExpression.internal(_from(_expressions.toList()));
 }
 
 /// Extension methods for a query returning zero or more rows with
@@ -2635,13 +2694,13 @@ extension Query4<A, B, C, D> on Query<(Expr<A>, Expr<B>, Expr<C>, Expr<D>)> {
   ) {
     final handle = Object();
     var offset = 0;
-    final a = _expressions.$1._standin(offset, handle);
-    offset += _expressions.$1._columns;
-    final b = _expressions.$2._standin(offset, handle);
-    offset += _expressions.$2._columns;
-    final c = _expressions.$3._standin(offset, handle);
-    offset += _expressions.$3._columns;
-    final d = _expressions.$4._standin(offset, handle);
+    final a = _expressions.$1.$standin(offset, handle);
+    offset += _expressions.$1.$columnCount;
+    final b = _expressions.$2.$standin(offset, handle);
+    offset += _expressions.$2.$columnCount;
+    final c = _expressions.$3.$standin(offset, handle);
+    offset += _expressions.$3.$columnCount;
+    final d = _expressions.$4.$standin(offset, handle);
     return (handle, builder(a, b, c, d));
   }
 
@@ -2657,7 +2716,7 @@ extension Query4<A, B, C, D> on Query<(Expr<A>, Expr<B>, Expr<C>, Expr<D>)> {
     return Query._(
       _context,
       _expressions,
-      (e) => WhereClause._(_from(e), handle, where),
+      (e) => WhereClause.internal(_from(e), handle, where),
     );
   }
 
@@ -2702,7 +2761,7 @@ extension Query4<A, B, C, D> on Query<(Expr<A>, Expr<B>, Expr<C>, Expr<D>)> {
       Query._(
         _context,
         _expressions,
-        (e) => OrderByClause._(_from(e), handle, orderBy),
+        (e) => OrderByClause.internal(_from(e), handle, orderBy),
       ),
     );
   }
@@ -2710,14 +2769,20 @@ extension Query4<A, B, C, D> on Query<(Expr<A>, Expr<B>, Expr<C>, Expr<D>)> {
   /// Limit [Query] using `LIMIT` clause.
   ///
   /// The resulting [Query] will only return the first [limit] rows.
-  Query<(Expr<A>, Expr<B>, Expr<C>, Expr<D>)> limit(int limit) =>
-      Query._(_context, _expressions, (e) => LimitClause._(_from(e), limit));
+  Query<(Expr<A>, Expr<B>, Expr<C>, Expr<D>)> limit(int limit) => Query._(
+    _context,
+    _expressions,
+    (e) => LimitClause.internal(_from(e), limit),
+  );
 
   /// Offset [Query] using `OFFSET` clause.
   ///
   /// The resulting [Query] will skip the first [offset] rows.
-  Query<(Expr<A>, Expr<B>, Expr<C>, Expr<D>)> offset(int offset) =>
-      Query._(_context, _expressions, (e) => OffsetClause._(_from(e), offset));
+  Query<(Expr<A>, Expr<B>, Expr<C>, Expr<D>)> offset(int offset) => Query._(
+    _context,
+    _expressions,
+    (e) => OffsetClause.internal(_from(e), offset),
+  );
 
   /// Limit [Query] to the first row using `LIMIT` clause.
   ///
@@ -2735,7 +2800,7 @@ extension Query4<A, B, C, D> on Query<(Expr<A>, Expr<B>, Expr<C>, Expr<D>)> {
   /// don't wish to count `null` values, use [where] to filter out such
   /// rows first.
   QuerySingle<(Expr<int>,)> count() =>
-      select((a, b, c, d) => (CountAllExpression._(),)).first;
+      select((a, b, c, d) => (CountAllExpression.internal(),)).first;
 
   /// Create a projection of this [Query] using `SELECT` clause.
   ///
@@ -2753,7 +2818,7 @@ extension Query4<A, B, C, D> on Query<(Expr<A>, Expr<B>, Expr<C>, Expr<D>)> {
     return Query._(
       _context,
       projection,
-      (e) => SelectFromClause._(_from(_expressions.toList()), handle, e),
+      (e) => SelectFromClause.internal(_from(_expressions.toList()), handle, e),
     );
   }
 
@@ -2801,32 +2866,36 @@ extension Query4<A, B, C, D> on Query<(Expr<A>, Expr<B>, Expr<C>, Expr<D>)> {
   /// > using `.asSubQuery.exists()` which returns an [Expr<bool>].
   QuerySingle<(Expr<bool>,)> exists() => QuerySingle._(
     Query._(_context, (
-      ExistsExpression._(_from(_expressions.toList())),
-    ), SelectClause._),
+      ExistsExpression.internal(_from(_expressions.toList())),
+    ), SelectClause.internal),
   );
 
   QueryClause _castAs(Query<(Expr<A>, Expr<B>, Expr<C>, Expr<D>)> as) {
     final (handle, projection) = _build(
       (a, b, c, d) => [
-        if (a._type is _ExprType<Null>)
-          ..._NullExprType._explodedCastAs(a, as._expressions.$1._type)
+        if (identical(a.$exprType, ColumnType.nullType))
+          ...explodedCastAs(a, as._expressions.$1.$exprType)
         else
           a,
-        if (b._type is _ExprType<Null>)
-          ..._NullExprType._explodedCastAs(b, as._expressions.$2._type)
+        if (identical(b.$exprType, ColumnType.nullType))
+          ...explodedCastAs(b, as._expressions.$2.$exprType)
         else
           b,
-        if (c._type is _ExprType<Null>)
-          ..._NullExprType._explodedCastAs(c, as._expressions.$3._type)
+        if (identical(c.$exprType, ColumnType.nullType))
+          ...explodedCastAs(c, as._expressions.$3.$exprType)
         else
           c,
-        if (d._type is _ExprType<Null>)
-          ..._NullExprType._explodedCastAs(d, as._expressions.$4._type)
+        if (identical(d.$exprType, ColumnType.nullType))
+          ...explodedCastAs(d, as._expressions.$4.$exprType)
         else
           d,
       ],
     );
-    return SelectFromClause._(_from(_expressions.toList()), handle, projection);
+    return SelectFromClause.internal(
+      _from(_expressions.toList()),
+      handle,
+      projection,
+    );
   }
 
   /// Combine this [Query] with [other] using `UNION` _set operator_.
@@ -2838,7 +2907,8 @@ extension Query4<A, B, C, D> on Query<(Expr<A>, Expr<B>, Expr<C>, Expr<D>)> {
   ) => Query._(
     _context,
     _expressions,
-    (e) => UnionClause._(_from(_expressions.toList()), other._castAs(this)),
+    (e) =>
+        UnionClause.internal(_from(_expressions.toList()), other._castAs(this)),
   );
 
   /// Combine this [Query] with [other] using `UNION ALL` _set operator_.
@@ -2850,7 +2920,10 @@ extension Query4<A, B, C, D> on Query<(Expr<A>, Expr<B>, Expr<C>, Expr<D>)> {
   ) => Query._(
     _context,
     _expressions,
-    (e) => UnionAllClause._(_from(_expressions.toList()), other._castAs(this)),
+    (e) => UnionAllClause.internal(
+      _from(_expressions.toList()),
+      other._castAs(this),
+    ),
   );
 
   /// Combine this [Query] with [other] using `INTERSECT` _set operator_.
@@ -2862,7 +2935,10 @@ extension Query4<A, B, C, D> on Query<(Expr<A>, Expr<B>, Expr<C>, Expr<D>)> {
   ) => Query._(
     _context,
     _expressions,
-    (e) => IntersectClause._(_from(_expressions.toList()), other._castAs(this)),
+    (e) => IntersectClause.internal(
+      _from(_expressions.toList()),
+      other._castAs(this),
+    ),
   );
 
   /// Combine this [Query] with [other] using `EXCEPT` _set operator_.
@@ -2875,7 +2951,10 @@ extension Query4<A, B, C, D> on Query<(Expr<A>, Expr<B>, Expr<C>, Expr<D>)> {
   ) => Query._(
     _context,
     _expressions,
-    (e) => ExceptClause._(_from(_expressions.toList()), other._castAs(this)),
+    (e) => ExceptClause.internal(
+      _from(_expressions.toList()),
+      other._castAs(this),
+    ),
   );
 
   /// Combine this [Query] with [other] using `UNION` _set operator_.
@@ -2933,11 +3012,11 @@ extension Query4<A, B, C, D> on Query<(Expr<A>, Expr<B>, Expr<C>, Expr<D>)> {
   /// Query the database for rows in this [Query] as a [Stream].
   Stream<(A, B, C, D)> stream() async* {
     final from = _from(_expressions.toList());
-    final decode1 = _expressions.$1._decode;
-    final decode2 = _expressions.$2._decode;
-    final decode3 = _expressions.$3._decode;
-    final decode4 = _expressions.$4._decode;
-    final task = _context._dialect.select(SelectStatement._(from));
+    final decode1 = _expressions.$1.$decode;
+    final decode2 = _expressions.$2.$decode;
+    final decode3 = _expressions.$3.$decode;
+    final decode4 = _expressions.$4.$decode;
+    final task = _context._dialect.select(SelectStatement.internal(from));
     await for (final row in _context._query(task)) {
       yield (
         decode1(row) as A,
@@ -2961,13 +3040,13 @@ extension SubQuery4<A, B, C, D>
   ) {
     final handle = Object();
     var offset = 0;
-    final a = _expressions.$1._standin(offset, handle);
-    offset += _expressions.$1._columns;
-    final b = _expressions.$2._standin(offset, handle);
-    offset += _expressions.$2._columns;
-    final c = _expressions.$3._standin(offset, handle);
-    offset += _expressions.$3._columns;
-    final d = _expressions.$4._standin(offset, handle);
+    final a = _expressions.$1.$standin(offset, handle);
+    offset += _expressions.$1.$columnCount;
+    final b = _expressions.$2.$standin(offset, handle);
+    offset += _expressions.$2.$columnCount;
+    final c = _expressions.$3.$standin(offset, handle);
+    offset += _expressions.$3.$columnCount;
+    final d = _expressions.$4.$standin(offset, handle);
     return (handle, builder(a, b, c, d));
   }
 
@@ -2982,7 +3061,7 @@ extension SubQuery4<A, B, C, D>
     final (handle, where) = _build(conditionBuilder);
     return SubQuery._(
       _expressions,
-      (e) => WhereClause._(_from(e), handle, where),
+      (e) => WhereClause.internal(_from(e), handle, where),
     );
   }
 
@@ -3026,7 +3105,7 @@ extension SubQuery4<A, B, C, D>
     return OrderedSubQuery._(
       SubQuery._(
         _expressions,
-        (e) => OrderByClause._(_from(e), handle, orderBy),
+        (e) => OrderByClause.internal(_from(e), handle, orderBy),
       ),
     );
   }
@@ -3035,13 +3114,13 @@ extension SubQuery4<A, B, C, D>
   ///
   /// The resulting [SubQuery] will only return the first [limit] rows.
   SubQuery<(Expr<A>, Expr<B>, Expr<C>, Expr<D>)> limit(int limit) =>
-      SubQuery._(_expressions, (e) => LimitClause._(_from(e), limit));
+      SubQuery._(_expressions, (e) => LimitClause.internal(_from(e), limit));
 
   /// Offset [SubQuery] using `OFFSET` clause.
   ///
   /// The resulting [SubQuery] will skip the first [offset] rows.
   SubQuery<(Expr<A>, Expr<B>, Expr<C>, Expr<D>)> offset(int offset) =>
-      SubQuery._(_expressions, (e) => OffsetClause._(_from(e), offset));
+      SubQuery._(_expressions, (e) => OffsetClause.internal(_from(e), offset));
 
   /// Count number of rows in this [SubQuery] using `COUNT(*)` aggregate
   /// function.
@@ -3052,8 +3131,9 @@ extension SubQuery4<A, B, C, D>
   /// This will count all rows, including rows with `null` values. If you
   /// don't wish to count `null` values, use [where] to filter out such
   /// rows first.
-  Expr<int> count() =>
-      select((a, b, c, d) => (CountAllExpression._(),)).first.asNotNull();
+  Expr<int> count() => select(
+    (a, b, c, d) => (CountAllExpression.internal(),),
+  ).first.asNotNull();
 
   /// Create a projection of this [SubQuery] using `SELECT` clause.
   ///
@@ -3070,7 +3150,7 @@ extension SubQuery4<A, B, C, D>
     final (handle, projection) = _build(projectionBuilder);
     return SubQuery._(
       projection,
-      (e) => SelectFromClause._(_from(_expressions.toList()), handle, e),
+      (e) => SelectFromClause.internal(_from(_expressions.toList()), handle, e),
     );
   }
 
@@ -3078,7 +3158,8 @@ extension SubQuery4<A, B, C, D>
   ///
   /// This returns an [Expr<bool>] that evaluates to `true`, if this [SubQuery]
   /// contains any rows, even if those rows are entirely `null`s.
-  Expr<bool> exists() => ExistsExpression._(_from(_expressions.toList()));
+  Expr<bool> exists() =>
+      ExistsExpression.internal(_from(_expressions.toList()));
 }
 
 /// Extension methods for a query returning zero or more rows with
@@ -3622,15 +3703,15 @@ extension Query5<A, B, C, D, E>
   ) {
     final handle = Object();
     var offset = 0;
-    final a = _expressions.$1._standin(offset, handle);
-    offset += _expressions.$1._columns;
-    final b = _expressions.$2._standin(offset, handle);
-    offset += _expressions.$2._columns;
-    final c = _expressions.$3._standin(offset, handle);
-    offset += _expressions.$3._columns;
-    final d = _expressions.$4._standin(offset, handle);
-    offset += _expressions.$4._columns;
-    final e = _expressions.$5._standin(offset, handle);
+    final a = _expressions.$1.$standin(offset, handle);
+    offset += _expressions.$1.$columnCount;
+    final b = _expressions.$2.$standin(offset, handle);
+    offset += _expressions.$2.$columnCount;
+    final c = _expressions.$3.$standin(offset, handle);
+    offset += _expressions.$3.$columnCount;
+    final d = _expressions.$4.$standin(offset, handle);
+    offset += _expressions.$4.$columnCount;
+    final e = _expressions.$5.$standin(offset, handle);
     return (handle, builder(a, b, c, d, e));
   }
 
@@ -3646,7 +3727,7 @@ extension Query5<A, B, C, D, E>
     return Query._(
       _context,
       _expressions,
-      (e) => WhereClause._(_from(e), handle, where),
+      (e) => WhereClause.internal(_from(e), handle, where),
     );
   }
 
@@ -3692,7 +3773,7 @@ extension Query5<A, B, C, D, E>
       Query._(
         _context,
         _expressions,
-        (e) => OrderByClause._(_from(e), handle, orderBy),
+        (e) => OrderByClause.internal(_from(e), handle, orderBy),
       ),
     );
   }
@@ -3701,13 +3782,21 @@ extension Query5<A, B, C, D, E>
   ///
   /// The resulting [Query] will only return the first [limit] rows.
   Query<(Expr<A>, Expr<B>, Expr<C>, Expr<D>, Expr<E>)> limit(int limit) =>
-      Query._(_context, _expressions, (e) => LimitClause._(_from(e), limit));
+      Query._(
+        _context,
+        _expressions,
+        (e) => LimitClause.internal(_from(e), limit),
+      );
 
   /// Offset [Query] using `OFFSET` clause.
   ///
   /// The resulting [Query] will skip the first [offset] rows.
   Query<(Expr<A>, Expr<B>, Expr<C>, Expr<D>, Expr<E>)> offset(int offset) =>
-      Query._(_context, _expressions, (e) => OffsetClause._(_from(e), offset));
+      Query._(
+        _context,
+        _expressions,
+        (e) => OffsetClause.internal(_from(e), offset),
+      );
 
   /// Limit [Query] to the first row using `LIMIT` clause.
   ///
@@ -3725,7 +3814,7 @@ extension Query5<A, B, C, D, E>
   /// don't wish to count `null` values, use [where] to filter out such
   /// rows first.
   QuerySingle<(Expr<int>,)> count() =>
-      select((a, b, c, d, e) => (CountAllExpression._(),)).first;
+      select((a, b, c, d, e) => (CountAllExpression.internal(),)).first;
 
   /// Create a projection of this [Query] using `SELECT` clause.
   ///
@@ -3744,7 +3833,7 @@ extension Query5<A, B, C, D, E>
     return Query._(
       _context,
       projection,
-      (e) => SelectFromClause._(_from(_expressions.toList()), handle, e),
+      (e) => SelectFromClause.internal(_from(_expressions.toList()), handle, e),
     );
   }
 
@@ -3790,36 +3879,40 @@ extension Query5<A, B, C, D, E>
   /// > using `.asSubQuery.exists()` which returns an [Expr<bool>].
   QuerySingle<(Expr<bool>,)> exists() => QuerySingle._(
     Query._(_context, (
-      ExistsExpression._(_from(_expressions.toList())),
-    ), SelectClause._),
+      ExistsExpression.internal(_from(_expressions.toList())),
+    ), SelectClause.internal),
   );
 
   QueryClause _castAs(Query<(Expr<A>, Expr<B>, Expr<C>, Expr<D>, Expr<E>)> as) {
     final (handle, projection) = _build(
       (a, b, c, d, e) => [
-        if (a._type is _ExprType<Null>)
-          ..._NullExprType._explodedCastAs(a, as._expressions.$1._type)
+        if (identical(a.$exprType, ColumnType.nullType))
+          ...explodedCastAs(a, as._expressions.$1.$exprType)
         else
           a,
-        if (b._type is _ExprType<Null>)
-          ..._NullExprType._explodedCastAs(b, as._expressions.$2._type)
+        if (identical(b.$exprType, ColumnType.nullType))
+          ...explodedCastAs(b, as._expressions.$2.$exprType)
         else
           b,
-        if (c._type is _ExprType<Null>)
-          ..._NullExprType._explodedCastAs(c, as._expressions.$3._type)
+        if (identical(c.$exprType, ColumnType.nullType))
+          ...explodedCastAs(c, as._expressions.$3.$exprType)
         else
           c,
-        if (d._type is _ExprType<Null>)
-          ..._NullExprType._explodedCastAs(d, as._expressions.$4._type)
+        if (identical(d.$exprType, ColumnType.nullType))
+          ...explodedCastAs(d, as._expressions.$4.$exprType)
         else
           d,
-        if (e._type is _ExprType<Null>)
-          ..._NullExprType._explodedCastAs(e, as._expressions.$5._type)
+        if (identical(e.$exprType, ColumnType.nullType))
+          ...explodedCastAs(e, as._expressions.$5.$exprType)
         else
           e,
       ],
     );
-    return SelectFromClause._(_from(_expressions.toList()), handle, projection);
+    return SelectFromClause.internal(
+      _from(_expressions.toList()),
+      handle,
+      projection,
+    );
   }
 
   /// Combine this [Query] with [other] using `UNION` _set operator_.
@@ -3831,7 +3924,8 @@ extension Query5<A, B, C, D, E>
   ) => Query._(
     _context,
     _expressions,
-    (e) => UnionClause._(_from(_expressions.toList()), other._castAs(this)),
+    (e) =>
+        UnionClause.internal(_from(_expressions.toList()), other._castAs(this)),
   );
 
   /// Combine this [Query] with [other] using `UNION ALL` _set operator_.
@@ -3843,7 +3937,10 @@ extension Query5<A, B, C, D, E>
   ) => Query._(
     _context,
     _expressions,
-    (e) => UnionAllClause._(_from(_expressions.toList()), other._castAs(this)),
+    (e) => UnionAllClause.internal(
+      _from(_expressions.toList()),
+      other._castAs(this),
+    ),
   );
 
   /// Combine this [Query] with [other] using `INTERSECT` _set operator_.
@@ -3855,7 +3952,10 @@ extension Query5<A, B, C, D, E>
   ) => Query._(
     _context,
     _expressions,
-    (e) => IntersectClause._(_from(_expressions.toList()), other._castAs(this)),
+    (e) => IntersectClause.internal(
+      _from(_expressions.toList()),
+      other._castAs(this),
+    ),
   );
 
   /// Combine this [Query] with [other] using `EXCEPT` _set operator_.
@@ -3868,7 +3968,10 @@ extension Query5<A, B, C, D, E>
   ) => Query._(
     _context,
     _expressions,
-    (e) => ExceptClause._(_from(_expressions.toList()), other._castAs(this)),
+    (e) => ExceptClause.internal(
+      _from(_expressions.toList()),
+      other._castAs(this),
+    ),
   );
 
   /// Combine this [Query] with [other] using `UNION` _set operator_.
@@ -3928,12 +4031,12 @@ extension Query5<A, B, C, D, E>
   /// Query the database for rows in this [Query] as a [Stream].
   Stream<(A, B, C, D, E)> stream() async* {
     final from = _from(_expressions.toList());
-    final decode1 = _expressions.$1._decode;
-    final decode2 = _expressions.$2._decode;
-    final decode3 = _expressions.$3._decode;
-    final decode4 = _expressions.$4._decode;
-    final decode5 = _expressions.$5._decode;
-    final task = _context._dialect.select(SelectStatement._(from));
+    final decode1 = _expressions.$1.$decode;
+    final decode2 = _expressions.$2.$decode;
+    final decode3 = _expressions.$3.$decode;
+    final decode4 = _expressions.$4.$decode;
+    final decode5 = _expressions.$5.$decode;
+    final task = _context._dialect.select(SelectStatement.internal(from));
     await for (final row in _context._query(task)) {
       yield (
         decode1(row) as A,
@@ -3958,15 +4061,15 @@ extension SubQuery5<A, B, C, D, E>
   ) {
     final handle = Object();
     var offset = 0;
-    final a = _expressions.$1._standin(offset, handle);
-    offset += _expressions.$1._columns;
-    final b = _expressions.$2._standin(offset, handle);
-    offset += _expressions.$2._columns;
-    final c = _expressions.$3._standin(offset, handle);
-    offset += _expressions.$3._columns;
-    final d = _expressions.$4._standin(offset, handle);
-    offset += _expressions.$4._columns;
-    final e = _expressions.$5._standin(offset, handle);
+    final a = _expressions.$1.$standin(offset, handle);
+    offset += _expressions.$1.$columnCount;
+    final b = _expressions.$2.$standin(offset, handle);
+    offset += _expressions.$2.$columnCount;
+    final c = _expressions.$3.$standin(offset, handle);
+    offset += _expressions.$3.$columnCount;
+    final d = _expressions.$4.$standin(offset, handle);
+    offset += _expressions.$4.$columnCount;
+    final e = _expressions.$5.$standin(offset, handle);
     return (handle, builder(a, b, c, d, e));
   }
 
@@ -3981,7 +4084,7 @@ extension SubQuery5<A, B, C, D, E>
     final (handle, where) = _build(conditionBuilder);
     return SubQuery._(
       _expressions,
-      (e) => WhereClause._(_from(e), handle, where),
+      (e) => WhereClause.internal(_from(e), handle, where),
     );
   }
 
@@ -4026,7 +4129,7 @@ extension SubQuery5<A, B, C, D, E>
     return OrderedSubQuery._(
       SubQuery._(
         _expressions,
-        (e) => OrderByClause._(_from(e), handle, orderBy),
+        (e) => OrderByClause.internal(_from(e), handle, orderBy),
       ),
     );
   }
@@ -4035,13 +4138,13 @@ extension SubQuery5<A, B, C, D, E>
   ///
   /// The resulting [SubQuery] will only return the first [limit] rows.
   SubQuery<(Expr<A>, Expr<B>, Expr<C>, Expr<D>, Expr<E>)> limit(int limit) =>
-      SubQuery._(_expressions, (e) => LimitClause._(_from(e), limit));
+      SubQuery._(_expressions, (e) => LimitClause.internal(_from(e), limit));
 
   /// Offset [SubQuery] using `OFFSET` clause.
   ///
   /// The resulting [SubQuery] will skip the first [offset] rows.
   SubQuery<(Expr<A>, Expr<B>, Expr<C>, Expr<D>, Expr<E>)> offset(int offset) =>
-      SubQuery._(_expressions, (e) => OffsetClause._(_from(e), offset));
+      SubQuery._(_expressions, (e) => OffsetClause.internal(_from(e), offset));
 
   /// Count number of rows in this [SubQuery] using `COUNT(*)` aggregate
   /// function.
@@ -4052,8 +4155,9 @@ extension SubQuery5<A, B, C, D, E>
   /// This will count all rows, including rows with `null` values. If you
   /// don't wish to count `null` values, use [where] to filter out such
   /// rows first.
-  Expr<int> count() =>
-      select((a, b, c, d, e) => (CountAllExpression._(),)).first.asNotNull();
+  Expr<int> count() => select(
+    (a, b, c, d, e) => (CountAllExpression.internal(),),
+  ).first.asNotNull();
 
   /// Create a projection of this [SubQuery] using `SELECT` clause.
   ///
@@ -4071,7 +4175,7 @@ extension SubQuery5<A, B, C, D, E>
     final (handle, projection) = _build(projectionBuilder);
     return SubQuery._(
       projection,
-      (e) => SelectFromClause._(_from(_expressions.toList()), handle, e),
+      (e) => SelectFromClause.internal(_from(_expressions.toList()), handle, e),
     );
   }
 
@@ -4079,7 +4183,8 @@ extension SubQuery5<A, B, C, D, E>
   ///
   /// This returns an [Expr<bool>] that evaluates to `true`, if this [SubQuery]
   /// contains any rows, even if those rows are entirely `null`s.
-  Expr<bool> exists() => ExistsExpression._(_from(_expressions.toList()));
+  Expr<bool> exists() =>
+      ExistsExpression.internal(_from(_expressions.toList()));
 }
 
 /// Extension methods for a query returning zero or more rows with
@@ -4644,17 +4749,17 @@ extension Query6<A, B, C, D, E, F>
   ) {
     final handle = Object();
     var offset = 0;
-    final a = _expressions.$1._standin(offset, handle);
-    offset += _expressions.$1._columns;
-    final b = _expressions.$2._standin(offset, handle);
-    offset += _expressions.$2._columns;
-    final c = _expressions.$3._standin(offset, handle);
-    offset += _expressions.$3._columns;
-    final d = _expressions.$4._standin(offset, handle);
-    offset += _expressions.$4._columns;
-    final e = _expressions.$5._standin(offset, handle);
-    offset += _expressions.$5._columns;
-    final f = _expressions.$6._standin(offset, handle);
+    final a = _expressions.$1.$standin(offset, handle);
+    offset += _expressions.$1.$columnCount;
+    final b = _expressions.$2.$standin(offset, handle);
+    offset += _expressions.$2.$columnCount;
+    final c = _expressions.$3.$standin(offset, handle);
+    offset += _expressions.$3.$columnCount;
+    final d = _expressions.$4.$standin(offset, handle);
+    offset += _expressions.$4.$columnCount;
+    final e = _expressions.$5.$standin(offset, handle);
+    offset += _expressions.$5.$columnCount;
+    final f = _expressions.$6.$standin(offset, handle);
     return (handle, builder(a, b, c, d, e, f));
   }
 
@@ -4677,7 +4782,7 @@ extension Query6<A, B, C, D, E, F>
     return Query._(
       _context,
       _expressions,
-      (e) => WhereClause._(_from(e), handle, where),
+      (e) => WhereClause.internal(_from(e), handle, where),
     );
   }
 
@@ -4724,7 +4829,7 @@ extension Query6<A, B, C, D, E, F>
       Query._(
         _context,
         _expressions,
-        (e) => OrderByClause._(_from(e), handle, orderBy),
+        (e) => OrderByClause.internal(_from(e), handle, orderBy),
       ),
     );
   }
@@ -4734,14 +4839,22 @@ extension Query6<A, B, C, D, E, F>
   /// The resulting [Query] will only return the first [limit] rows.
   Query<(Expr<A>, Expr<B>, Expr<C>, Expr<D>, Expr<E>, Expr<F>)> limit(
     int limit,
-  ) => Query._(_context, _expressions, (e) => LimitClause._(_from(e), limit));
+  ) => Query._(
+    _context,
+    _expressions,
+    (e) => LimitClause.internal(_from(e), limit),
+  );
 
   /// Offset [Query] using `OFFSET` clause.
   ///
   /// The resulting [Query] will skip the first [offset] rows.
   Query<(Expr<A>, Expr<B>, Expr<C>, Expr<D>, Expr<E>, Expr<F>)> offset(
     int offset,
-  ) => Query._(_context, _expressions, (e) => OffsetClause._(_from(e), offset));
+  ) => Query._(
+    _context,
+    _expressions,
+    (e) => OffsetClause.internal(_from(e), offset),
+  );
 
   /// Limit [Query] to the first row using `LIMIT` clause.
   ///
@@ -4759,7 +4872,7 @@ extension Query6<A, B, C, D, E, F>
   /// don't wish to count `null` values, use [where] to filter out such
   /// rows first.
   QuerySingle<(Expr<int>,)> count() =>
-      select((a, b, c, d, e, f) => (CountAllExpression._(),)).first;
+      select((a, b, c, d, e, f) => (CountAllExpression.internal(),)).first;
 
   /// Create a projection of this [Query] using `SELECT` clause.
   ///
@@ -4778,7 +4891,7 @@ extension Query6<A, B, C, D, E, F>
     return Query._(
       _context,
       projection,
-      (e) => SelectFromClause._(_from(_expressions.toList()), handle, e),
+      (e) => SelectFromClause.internal(_from(_expressions.toList()), handle, e),
     );
   }
 
@@ -4824,8 +4937,8 @@ extension Query6<A, B, C, D, E, F>
   /// > using `.asSubQuery.exists()` which returns an [Expr<bool>].
   QuerySingle<(Expr<bool>,)> exists() => QuerySingle._(
     Query._(_context, (
-      ExistsExpression._(_from(_expressions.toList())),
-    ), SelectClause._),
+      ExistsExpression.internal(_from(_expressions.toList())),
+    ), SelectClause.internal),
   );
 
   QueryClause _castAs(
@@ -4833,33 +4946,37 @@ extension Query6<A, B, C, D, E, F>
   ) {
     final (handle, projection) = _build(
       (a, b, c, d, e, f) => [
-        if (a._type is _ExprType<Null>)
-          ..._NullExprType._explodedCastAs(a, as._expressions.$1._type)
+        if (identical(a.$exprType, ColumnType.nullType))
+          ...explodedCastAs(a, as._expressions.$1.$exprType)
         else
           a,
-        if (b._type is _ExprType<Null>)
-          ..._NullExprType._explodedCastAs(b, as._expressions.$2._type)
+        if (identical(b.$exprType, ColumnType.nullType))
+          ...explodedCastAs(b, as._expressions.$2.$exprType)
         else
           b,
-        if (c._type is _ExprType<Null>)
-          ..._NullExprType._explodedCastAs(c, as._expressions.$3._type)
+        if (identical(c.$exprType, ColumnType.nullType))
+          ...explodedCastAs(c, as._expressions.$3.$exprType)
         else
           c,
-        if (d._type is _ExprType<Null>)
-          ..._NullExprType._explodedCastAs(d, as._expressions.$4._type)
+        if (identical(d.$exprType, ColumnType.nullType))
+          ...explodedCastAs(d, as._expressions.$4.$exprType)
         else
           d,
-        if (e._type is _ExprType<Null>)
-          ..._NullExprType._explodedCastAs(e, as._expressions.$5._type)
+        if (identical(e.$exprType, ColumnType.nullType))
+          ...explodedCastAs(e, as._expressions.$5.$exprType)
         else
           e,
-        if (f._type is _ExprType<Null>)
-          ..._NullExprType._explodedCastAs(f, as._expressions.$6._type)
+        if (identical(f.$exprType, ColumnType.nullType))
+          ...explodedCastAs(f, as._expressions.$6.$exprType)
         else
           f,
       ],
     );
-    return SelectFromClause._(_from(_expressions.toList()), handle, projection);
+    return SelectFromClause.internal(
+      _from(_expressions.toList()),
+      handle,
+      projection,
+    );
   }
 
   /// Combine this [Query] with [other] using `UNION` _set operator_.
@@ -4871,7 +4988,8 @@ extension Query6<A, B, C, D, E, F>
   ) => Query._(
     _context,
     _expressions,
-    (e) => UnionClause._(_from(_expressions.toList()), other._castAs(this)),
+    (e) =>
+        UnionClause.internal(_from(_expressions.toList()), other._castAs(this)),
   );
 
   /// Combine this [Query] with [other] using `UNION ALL` _set operator_.
@@ -4883,7 +5001,10 @@ extension Query6<A, B, C, D, E, F>
   ) => Query._(
     _context,
     _expressions,
-    (e) => UnionAllClause._(_from(_expressions.toList()), other._castAs(this)),
+    (e) => UnionAllClause.internal(
+      _from(_expressions.toList()),
+      other._castAs(this),
+    ),
   );
 
   /// Combine this [Query] with [other] using `INTERSECT` _set operator_.
@@ -4895,7 +5016,10 @@ extension Query6<A, B, C, D, E, F>
   ) => Query._(
     _context,
     _expressions,
-    (e) => IntersectClause._(_from(_expressions.toList()), other._castAs(this)),
+    (e) => IntersectClause.internal(
+      _from(_expressions.toList()),
+      other._castAs(this),
+    ),
   );
 
   /// Combine this [Query] with [other] using `EXCEPT` _set operator_.
@@ -4908,7 +5032,10 @@ extension Query6<A, B, C, D, E, F>
   ) => Query._(
     _context,
     _expressions,
-    (e) => ExceptClause._(_from(_expressions.toList()), other._castAs(this)),
+    (e) => ExceptClause.internal(
+      _from(_expressions.toList()),
+      other._castAs(this),
+    ),
   );
 
   /// Combine this [Query] with [other] using `UNION` _set operator_.
@@ -4968,13 +5095,13 @@ extension Query6<A, B, C, D, E, F>
   /// Query the database for rows in this [Query] as a [Stream].
   Stream<(A, B, C, D, E, F)> stream() async* {
     final from = _from(_expressions.toList());
-    final decode1 = _expressions.$1._decode;
-    final decode2 = _expressions.$2._decode;
-    final decode3 = _expressions.$3._decode;
-    final decode4 = _expressions.$4._decode;
-    final decode5 = _expressions.$5._decode;
-    final decode6 = _expressions.$6._decode;
-    final task = _context._dialect.select(SelectStatement._(from));
+    final decode1 = _expressions.$1.$decode;
+    final decode2 = _expressions.$2.$decode;
+    final decode3 = _expressions.$3.$decode;
+    final decode4 = _expressions.$4.$decode;
+    final decode5 = _expressions.$5.$decode;
+    final decode6 = _expressions.$6.$decode;
+    final task = _context._dialect.select(SelectStatement.internal(from));
     await for (final row in _context._query(task)) {
       yield (
         decode1(row) as A,
@@ -5001,17 +5128,17 @@ extension SubQuery6<A, B, C, D, E, F>
   ) {
     final handle = Object();
     var offset = 0;
-    final a = _expressions.$1._standin(offset, handle);
-    offset += _expressions.$1._columns;
-    final b = _expressions.$2._standin(offset, handle);
-    offset += _expressions.$2._columns;
-    final c = _expressions.$3._standin(offset, handle);
-    offset += _expressions.$3._columns;
-    final d = _expressions.$4._standin(offset, handle);
-    offset += _expressions.$4._columns;
-    final e = _expressions.$5._standin(offset, handle);
-    offset += _expressions.$5._columns;
-    final f = _expressions.$6._standin(offset, handle);
+    final a = _expressions.$1.$standin(offset, handle);
+    offset += _expressions.$1.$columnCount;
+    final b = _expressions.$2.$standin(offset, handle);
+    offset += _expressions.$2.$columnCount;
+    final c = _expressions.$3.$standin(offset, handle);
+    offset += _expressions.$3.$columnCount;
+    final d = _expressions.$4.$standin(offset, handle);
+    offset += _expressions.$4.$columnCount;
+    final e = _expressions.$5.$standin(offset, handle);
+    offset += _expressions.$5.$columnCount;
+    final f = _expressions.$6.$standin(offset, handle);
     return (handle, builder(a, b, c, d, e, f));
   }
 
@@ -5033,7 +5160,7 @@ extension SubQuery6<A, B, C, D, E, F>
     final (handle, where) = _build(conditionBuilder);
     return SubQuery._(
       _expressions,
-      (e) => WhereClause._(_from(e), handle, where),
+      (e) => WhereClause.internal(_from(e), handle, where),
     );
   }
 
@@ -5080,7 +5207,7 @@ extension SubQuery6<A, B, C, D, E, F>
     return OrderedSubQuery._(
       SubQuery._(
         _expressions,
-        (e) => OrderByClause._(_from(e), handle, orderBy),
+        (e) => OrderByClause.internal(_from(e), handle, orderBy),
       ),
     );
   }
@@ -5090,14 +5217,14 @@ extension SubQuery6<A, B, C, D, E, F>
   /// The resulting [SubQuery] will only return the first [limit] rows.
   SubQuery<(Expr<A>, Expr<B>, Expr<C>, Expr<D>, Expr<E>, Expr<F>)> limit(
     int limit,
-  ) => SubQuery._(_expressions, (e) => LimitClause._(_from(e), limit));
+  ) => SubQuery._(_expressions, (e) => LimitClause.internal(_from(e), limit));
 
   /// Offset [SubQuery] using `OFFSET` clause.
   ///
   /// The resulting [SubQuery] will skip the first [offset] rows.
   SubQuery<(Expr<A>, Expr<B>, Expr<C>, Expr<D>, Expr<E>, Expr<F>)> offset(
     int offset,
-  ) => SubQuery._(_expressions, (e) => OffsetClause._(_from(e), offset));
+  ) => SubQuery._(_expressions, (e) => OffsetClause.internal(_from(e), offset));
 
   /// Count number of rows in this [SubQuery] using `COUNT(*)` aggregate
   /// function.
@@ -5108,8 +5235,9 @@ extension SubQuery6<A, B, C, D, E, F>
   /// This will count all rows, including rows with `null` values. If you
   /// don't wish to count `null` values, use [where] to filter out such
   /// rows first.
-  Expr<int> count() =>
-      select((a, b, c, d, e, f) => (CountAllExpression._(),)).first.asNotNull();
+  Expr<int> count() => select(
+    (a, b, c, d, e, f) => (CountAllExpression.internal(),),
+  ).first.asNotNull();
 
   /// Create a projection of this [SubQuery] using `SELECT` clause.
   ///
@@ -5127,7 +5255,7 @@ extension SubQuery6<A, B, C, D, E, F>
     final (handle, projection) = _build(projectionBuilder);
     return SubQuery._(
       projection,
-      (e) => SelectFromClause._(_from(_expressions.toList()), handle, e),
+      (e) => SelectFromClause.internal(_from(_expressions.toList()), handle, e),
     );
   }
 
@@ -5135,7 +5263,8 @@ extension SubQuery6<A, B, C, D, E, F>
   ///
   /// This returns an [Expr<bool>] that evaluates to `true`, if this [SubQuery]
   /// contains any rows, even if those rows are entirely `null`s.
-  Expr<bool> exists() => ExistsExpression._(_from(_expressions.toList()));
+  Expr<bool> exists() =>
+      ExistsExpression.internal(_from(_expressions.toList()));
 }
 
 /// Extension methods for a query returning zero or more rows with
@@ -5754,19 +5883,19 @@ extension Query7<A, B, C, D, E, F, G>
   ) {
     final handle = Object();
     var offset = 0;
-    final a = _expressions.$1._standin(offset, handle);
-    offset += _expressions.$1._columns;
-    final b = _expressions.$2._standin(offset, handle);
-    offset += _expressions.$2._columns;
-    final c = _expressions.$3._standin(offset, handle);
-    offset += _expressions.$3._columns;
-    final d = _expressions.$4._standin(offset, handle);
-    offset += _expressions.$4._columns;
-    final e = _expressions.$5._standin(offset, handle);
-    offset += _expressions.$5._columns;
-    final f = _expressions.$6._standin(offset, handle);
-    offset += _expressions.$6._columns;
-    final g = _expressions.$7._standin(offset, handle);
+    final a = _expressions.$1.$standin(offset, handle);
+    offset += _expressions.$1.$columnCount;
+    final b = _expressions.$2.$standin(offset, handle);
+    offset += _expressions.$2.$columnCount;
+    final c = _expressions.$3.$standin(offset, handle);
+    offset += _expressions.$3.$columnCount;
+    final d = _expressions.$4.$standin(offset, handle);
+    offset += _expressions.$4.$columnCount;
+    final e = _expressions.$5.$standin(offset, handle);
+    offset += _expressions.$5.$columnCount;
+    final f = _expressions.$6.$standin(offset, handle);
+    offset += _expressions.$6.$columnCount;
+    final g = _expressions.$7.$standin(offset, handle);
     return (handle, builder(a, b, c, d, e, f, g));
   }
 
@@ -5790,7 +5919,7 @@ extension Query7<A, B, C, D, E, F, G>
     return Query._(
       _context,
       _expressions,
-      (e) => WhereClause._(_from(e), handle, where),
+      (e) => WhereClause.internal(_from(e), handle, where),
     );
   }
 
@@ -5839,7 +5968,7 @@ extension Query7<A, B, C, D, E, F, G>
       Query._(
         _context,
         _expressions,
-        (e) => OrderByClause._(_from(e), handle, orderBy),
+        (e) => OrderByClause.internal(_from(e), handle, orderBy),
       ),
     );
   }
@@ -5849,14 +5978,22 @@ extension Query7<A, B, C, D, E, F, G>
   /// The resulting [Query] will only return the first [limit] rows.
   Query<(Expr<A>, Expr<B>, Expr<C>, Expr<D>, Expr<E>, Expr<F>, Expr<G>)> limit(
     int limit,
-  ) => Query._(_context, _expressions, (e) => LimitClause._(_from(e), limit));
+  ) => Query._(
+    _context,
+    _expressions,
+    (e) => LimitClause.internal(_from(e), limit),
+  );
 
   /// Offset [Query] using `OFFSET` clause.
   ///
   /// The resulting [Query] will skip the first [offset] rows.
   Query<(Expr<A>, Expr<B>, Expr<C>, Expr<D>, Expr<E>, Expr<F>, Expr<G>)> offset(
     int offset,
-  ) => Query._(_context, _expressions, (e) => OffsetClause._(_from(e), offset));
+  ) => Query._(
+    _context,
+    _expressions,
+    (e) => OffsetClause.internal(_from(e), offset),
+  );
 
   /// Limit [Query] to the first row using `LIMIT` clause.
   ///
@@ -5874,7 +6011,7 @@ extension Query7<A, B, C, D, E, F, G>
   /// don't wish to count `null` values, use [where] to filter out such
   /// rows first.
   QuerySingle<(Expr<int>,)> count() =>
-      select((a, b, c, d, e, f, g) => (CountAllExpression._(),)).first;
+      select((a, b, c, d, e, f, g) => (CountAllExpression.internal(),)).first;
 
   /// Create a projection of this [Query] using `SELECT` clause.
   ///
@@ -5901,7 +6038,7 @@ extension Query7<A, B, C, D, E, F, G>
     return Query._(
       _context,
       projection,
-      (e) => SelectFromClause._(_from(_expressions.toList()), handle, e),
+      (e) => SelectFromClause.internal(_from(_expressions.toList()), handle, e),
     );
   }
 
@@ -5947,8 +6084,8 @@ extension Query7<A, B, C, D, E, F, G>
   /// > using `.asSubQuery.exists()` which returns an [Expr<bool>].
   QuerySingle<(Expr<bool>,)> exists() => QuerySingle._(
     Query._(_context, (
-      ExistsExpression._(_from(_expressions.toList())),
-    ), SelectClause._),
+      ExistsExpression.internal(_from(_expressions.toList())),
+    ), SelectClause.internal),
   );
 
   QueryClause _castAs(
@@ -5956,37 +6093,41 @@ extension Query7<A, B, C, D, E, F, G>
   ) {
     final (handle, projection) = _build(
       (a, b, c, d, e, f, g) => [
-        if (a._type is _ExprType<Null>)
-          ..._NullExprType._explodedCastAs(a, as._expressions.$1._type)
+        if (identical(a.$exprType, ColumnType.nullType))
+          ...explodedCastAs(a, as._expressions.$1.$exprType)
         else
           a,
-        if (b._type is _ExprType<Null>)
-          ..._NullExprType._explodedCastAs(b, as._expressions.$2._type)
+        if (identical(b.$exprType, ColumnType.nullType))
+          ...explodedCastAs(b, as._expressions.$2.$exprType)
         else
           b,
-        if (c._type is _ExprType<Null>)
-          ..._NullExprType._explodedCastAs(c, as._expressions.$3._type)
+        if (identical(c.$exprType, ColumnType.nullType))
+          ...explodedCastAs(c, as._expressions.$3.$exprType)
         else
           c,
-        if (d._type is _ExprType<Null>)
-          ..._NullExprType._explodedCastAs(d, as._expressions.$4._type)
+        if (identical(d.$exprType, ColumnType.nullType))
+          ...explodedCastAs(d, as._expressions.$4.$exprType)
         else
           d,
-        if (e._type is _ExprType<Null>)
-          ..._NullExprType._explodedCastAs(e, as._expressions.$5._type)
+        if (identical(e.$exprType, ColumnType.nullType))
+          ...explodedCastAs(e, as._expressions.$5.$exprType)
         else
           e,
-        if (f._type is _ExprType<Null>)
-          ..._NullExprType._explodedCastAs(f, as._expressions.$6._type)
+        if (identical(f.$exprType, ColumnType.nullType))
+          ...explodedCastAs(f, as._expressions.$6.$exprType)
         else
           f,
-        if (g._type is _ExprType<Null>)
-          ..._NullExprType._explodedCastAs(g, as._expressions.$7._type)
+        if (identical(g.$exprType, ColumnType.nullType))
+          ...explodedCastAs(g, as._expressions.$7.$exprType)
         else
           g,
       ],
     );
-    return SelectFromClause._(_from(_expressions.toList()), handle, projection);
+    return SelectFromClause.internal(
+      _from(_expressions.toList()),
+      handle,
+      projection,
+    );
   }
 
   /// Combine this [Query] with [other] using `UNION` _set operator_.
@@ -5999,7 +6140,8 @@ extension Query7<A, B, C, D, E, F, G>
   ) => Query._(
     _context,
     _expressions,
-    (e) => UnionClause._(_from(_expressions.toList()), other._castAs(this)),
+    (e) =>
+        UnionClause.internal(_from(_expressions.toList()), other._castAs(this)),
   );
 
   /// Combine this [Query] with [other] using `UNION ALL` _set operator_.
@@ -6013,7 +6155,10 @@ extension Query7<A, B, C, D, E, F, G>
   ) => Query._(
     _context,
     _expressions,
-    (e) => UnionAllClause._(_from(_expressions.toList()), other._castAs(this)),
+    (e) => UnionAllClause.internal(
+      _from(_expressions.toList()),
+      other._castAs(this),
+    ),
   );
 
   /// Combine this [Query] with [other] using `INTERSECT` _set operator_.
@@ -6027,7 +6172,10 @@ extension Query7<A, B, C, D, E, F, G>
   ) => Query._(
     _context,
     _expressions,
-    (e) => IntersectClause._(_from(_expressions.toList()), other._castAs(this)),
+    (e) => IntersectClause.internal(
+      _from(_expressions.toList()),
+      other._castAs(this),
+    ),
   );
 
   /// Combine this [Query] with [other] using `EXCEPT` _set operator_.
@@ -6041,7 +6189,10 @@ extension Query7<A, B, C, D, E, F, G>
   ) => Query._(
     _context,
     _expressions,
-    (e) => ExceptClause._(_from(_expressions.toList()), other._castAs(this)),
+    (e) => ExceptClause.internal(
+      _from(_expressions.toList()),
+      other._castAs(this),
+    ),
   );
 
   /// Combine this [Query] with [other] using `UNION` _set operator_.
@@ -6117,14 +6268,14 @@ extension Query7<A, B, C, D, E, F, G>
   /// Query the database for rows in this [Query] as a [Stream].
   Stream<(A, B, C, D, E, F, G)> stream() async* {
     final from = _from(_expressions.toList());
-    final decode1 = _expressions.$1._decode;
-    final decode2 = _expressions.$2._decode;
-    final decode3 = _expressions.$3._decode;
-    final decode4 = _expressions.$4._decode;
-    final decode5 = _expressions.$5._decode;
-    final decode6 = _expressions.$6._decode;
-    final decode7 = _expressions.$7._decode;
-    final task = _context._dialect.select(SelectStatement._(from));
+    final decode1 = _expressions.$1.$decode;
+    final decode2 = _expressions.$2.$decode;
+    final decode3 = _expressions.$3.$decode;
+    final decode4 = _expressions.$4.$decode;
+    final decode5 = _expressions.$5.$decode;
+    final decode6 = _expressions.$6.$decode;
+    final decode7 = _expressions.$7.$decode;
+    final task = _context._dialect.select(SelectStatement.internal(from));
     await for (final row in _context._query(task)) {
       yield (
         decode1(row) as A,
@@ -6163,19 +6314,19 @@ extension SubQuery7<A, B, C, D, E, F, G>
   ) {
     final handle = Object();
     var offset = 0;
-    final a = _expressions.$1._standin(offset, handle);
-    offset += _expressions.$1._columns;
-    final b = _expressions.$2._standin(offset, handle);
-    offset += _expressions.$2._columns;
-    final c = _expressions.$3._standin(offset, handle);
-    offset += _expressions.$3._columns;
-    final d = _expressions.$4._standin(offset, handle);
-    offset += _expressions.$4._columns;
-    final e = _expressions.$5._standin(offset, handle);
-    offset += _expressions.$5._columns;
-    final f = _expressions.$6._standin(offset, handle);
-    offset += _expressions.$6._columns;
-    final g = _expressions.$7._standin(offset, handle);
+    final a = _expressions.$1.$standin(offset, handle);
+    offset += _expressions.$1.$columnCount;
+    final b = _expressions.$2.$standin(offset, handle);
+    offset += _expressions.$2.$columnCount;
+    final c = _expressions.$3.$standin(offset, handle);
+    offset += _expressions.$3.$columnCount;
+    final d = _expressions.$4.$standin(offset, handle);
+    offset += _expressions.$4.$columnCount;
+    final e = _expressions.$5.$standin(offset, handle);
+    offset += _expressions.$5.$columnCount;
+    final f = _expressions.$6.$standin(offset, handle);
+    offset += _expressions.$6.$columnCount;
+    final g = _expressions.$7.$standin(offset, handle);
     return (handle, builder(a, b, c, d, e, f, g));
   }
 
@@ -6199,7 +6350,7 @@ extension SubQuery7<A, B, C, D, E, F, G>
     final (handle, where) = _build(conditionBuilder);
     return SubQuery._(
       _expressions,
-      (e) => WhereClause._(_from(e), handle, where),
+      (e) => WhereClause.internal(_from(e), handle, where),
     );
   }
 
@@ -6249,7 +6400,7 @@ extension SubQuery7<A, B, C, D, E, F, G>
     return OrderedSubQuery._(
       SubQuery._(
         _expressions,
-        (e) => OrderByClause._(_from(e), handle, orderBy),
+        (e) => OrderByClause.internal(_from(e), handle, orderBy),
       ),
     );
   }
@@ -6259,14 +6410,14 @@ extension SubQuery7<A, B, C, D, E, F, G>
   /// The resulting [SubQuery] will only return the first [limit] rows.
   SubQuery<(Expr<A>, Expr<B>, Expr<C>, Expr<D>, Expr<E>, Expr<F>, Expr<G>)>
   limit(int limit) =>
-      SubQuery._(_expressions, (e) => LimitClause._(_from(e), limit));
+      SubQuery._(_expressions, (e) => LimitClause.internal(_from(e), limit));
 
   /// Offset [SubQuery] using `OFFSET` clause.
   ///
   /// The resulting [SubQuery] will skip the first [offset] rows.
   SubQuery<(Expr<A>, Expr<B>, Expr<C>, Expr<D>, Expr<E>, Expr<F>, Expr<G>)>
   offset(int offset) =>
-      SubQuery._(_expressions, (e) => OffsetClause._(_from(e), offset));
+      SubQuery._(_expressions, (e) => OffsetClause.internal(_from(e), offset));
 
   /// Count number of rows in this [SubQuery] using `COUNT(*)` aggregate
   /// function.
@@ -6278,7 +6429,7 @@ extension SubQuery7<A, B, C, D, E, F, G>
   /// don't wish to count `null` values, use [where] to filter out such
   /// rows first.
   Expr<int> count() => select(
-    (a, b, c, d, e, f, g) => (CountAllExpression._(),),
+    (a, b, c, d, e, f, g) => (CountAllExpression.internal(),),
   ).first.asNotNull();
 
   /// Create a projection of this [SubQuery] using `SELECT` clause.
@@ -6305,7 +6456,7 @@ extension SubQuery7<A, B, C, D, E, F, G>
     final (handle, projection) = _build(projectionBuilder);
     return SubQuery._(
       projection,
-      (e) => SelectFromClause._(_from(_expressions.toList()), handle, e),
+      (e) => SelectFromClause.internal(_from(_expressions.toList()), handle, e),
     );
   }
 
@@ -6313,7 +6464,8 @@ extension SubQuery7<A, B, C, D, E, F, G>
   ///
   /// This returns an [Expr<bool>] that evaluates to `true`, if this [SubQuery]
   /// contains any rows, even if those rows are entirely `null`s.
-  Expr<bool> exists() => ExistsExpression._(_from(_expressions.toList()));
+  Expr<bool> exists() =>
+      ExistsExpression.internal(_from(_expressions.toList()));
 }
 
 /// Extension methods for a query returning zero or more rows with
@@ -7025,21 +7177,21 @@ extension Query8<A, B, C, D, E, F, G, H>
   ) {
     final handle = Object();
     var offset = 0;
-    final a = _expressions.$1._standin(offset, handle);
-    offset += _expressions.$1._columns;
-    final b = _expressions.$2._standin(offset, handle);
-    offset += _expressions.$2._columns;
-    final c = _expressions.$3._standin(offset, handle);
-    offset += _expressions.$3._columns;
-    final d = _expressions.$4._standin(offset, handle);
-    offset += _expressions.$4._columns;
-    final e = _expressions.$5._standin(offset, handle);
-    offset += _expressions.$5._columns;
-    final f = _expressions.$6._standin(offset, handle);
-    offset += _expressions.$6._columns;
-    final g = _expressions.$7._standin(offset, handle);
-    offset += _expressions.$7._columns;
-    final h = _expressions.$8._standin(offset, handle);
+    final a = _expressions.$1.$standin(offset, handle);
+    offset += _expressions.$1.$columnCount;
+    final b = _expressions.$2.$standin(offset, handle);
+    offset += _expressions.$2.$columnCount;
+    final c = _expressions.$3.$standin(offset, handle);
+    offset += _expressions.$3.$columnCount;
+    final d = _expressions.$4.$standin(offset, handle);
+    offset += _expressions.$4.$columnCount;
+    final e = _expressions.$5.$standin(offset, handle);
+    offset += _expressions.$5.$columnCount;
+    final f = _expressions.$6.$standin(offset, handle);
+    offset += _expressions.$6.$columnCount;
+    final g = _expressions.$7.$standin(offset, handle);
+    offset += _expressions.$7.$columnCount;
+    final h = _expressions.$8.$standin(offset, handle);
     return (handle, builder(a, b, c, d, e, f, g, h));
   }
 
@@ -7067,7 +7219,7 @@ extension Query8<A, B, C, D, E, F, G, H>
     return Query._(
       _context,
       _expressions,
-      (e) => WhereClause._(_from(e), handle, where),
+      (e) => WhereClause.internal(_from(e), handle, where),
     );
   }
 
@@ -7119,7 +7271,7 @@ extension Query8<A, B, C, D, E, F, G, H>
       Query._(
         _context,
         _expressions,
-        (e) => OrderByClause._(_from(e), handle, orderBy),
+        (e) => OrderByClause.internal(_from(e), handle, orderBy),
       ),
     );
   }
@@ -7130,8 +7282,11 @@ extension Query8<A, B, C, D, E, F, G, H>
   Query<
     (Expr<A>, Expr<B>, Expr<C>, Expr<D>, Expr<E>, Expr<F>, Expr<G>, Expr<H>)
   >
-  limit(int limit) =>
-      Query._(_context, _expressions, (e) => LimitClause._(_from(e), limit));
+  limit(int limit) => Query._(
+    _context,
+    _expressions,
+    (e) => LimitClause.internal(_from(e), limit),
+  );
 
   /// Offset [Query] using `OFFSET` clause.
   ///
@@ -7139,8 +7294,11 @@ extension Query8<A, B, C, D, E, F, G, H>
   Query<
     (Expr<A>, Expr<B>, Expr<C>, Expr<D>, Expr<E>, Expr<F>, Expr<G>, Expr<H>)
   >
-  offset(int offset) =>
-      Query._(_context, _expressions, (e) => OffsetClause._(_from(e), offset));
+  offset(int offset) => Query._(
+    _context,
+    _expressions,
+    (e) => OffsetClause.internal(_from(e), offset),
+  );
 
   /// Limit [Query] to the first row using `LIMIT` clause.
   ///
@@ -7159,8 +7317,9 @@ extension Query8<A, B, C, D, E, F, G, H>
   /// This will count all rows, including rows with `null` values. If you
   /// don't wish to count `null` values, use [where] to filter out such
   /// rows first.
-  QuerySingle<(Expr<int>,)> count() =>
-      select((a, b, c, d, e, f, g, h) => (CountAllExpression._(),)).first;
+  QuerySingle<(Expr<int>,)> count() => select(
+    (a, b, c, d, e, f, g, h) => (CountAllExpression.internal(),),
+  ).first;
 
   /// Create a projection of this [Query] using `SELECT` clause.
   ///
@@ -7188,7 +7347,7 @@ extension Query8<A, B, C, D, E, F, G, H>
     return Query._(
       _context,
       projection,
-      (e) => SelectFromClause._(_from(_expressions.toList()), handle, e),
+      (e) => SelectFromClause.internal(_from(_expressions.toList()), handle, e),
     );
   }
 
@@ -7243,8 +7402,8 @@ extension Query8<A, B, C, D, E, F, G, H>
   /// > using `.asSubQuery.exists()` which returns an [Expr<bool>].
   QuerySingle<(Expr<bool>,)> exists() => QuerySingle._(
     Query._(_context, (
-      ExistsExpression._(_from(_expressions.toList())),
-    ), SelectClause._),
+      ExistsExpression.internal(_from(_expressions.toList())),
+    ), SelectClause.internal),
   );
 
   QueryClause _castAs(
@@ -7255,41 +7414,45 @@ extension Query8<A, B, C, D, E, F, G, H>
   ) {
     final (handle, projection) = _build(
       (a, b, c, d, e, f, g, h) => [
-        if (a._type is _ExprType<Null>)
-          ..._NullExprType._explodedCastAs(a, as._expressions.$1._type)
+        if (identical(a.$exprType, ColumnType.nullType))
+          ...explodedCastAs(a, as._expressions.$1.$exprType)
         else
           a,
-        if (b._type is _ExprType<Null>)
-          ..._NullExprType._explodedCastAs(b, as._expressions.$2._type)
+        if (identical(b.$exprType, ColumnType.nullType))
+          ...explodedCastAs(b, as._expressions.$2.$exprType)
         else
           b,
-        if (c._type is _ExprType<Null>)
-          ..._NullExprType._explodedCastAs(c, as._expressions.$3._type)
+        if (identical(c.$exprType, ColumnType.nullType))
+          ...explodedCastAs(c, as._expressions.$3.$exprType)
         else
           c,
-        if (d._type is _ExprType<Null>)
-          ..._NullExprType._explodedCastAs(d, as._expressions.$4._type)
+        if (identical(d.$exprType, ColumnType.nullType))
+          ...explodedCastAs(d, as._expressions.$4.$exprType)
         else
           d,
-        if (e._type is _ExprType<Null>)
-          ..._NullExprType._explodedCastAs(e, as._expressions.$5._type)
+        if (identical(e.$exprType, ColumnType.nullType))
+          ...explodedCastAs(e, as._expressions.$5.$exprType)
         else
           e,
-        if (f._type is _ExprType<Null>)
-          ..._NullExprType._explodedCastAs(f, as._expressions.$6._type)
+        if (identical(f.$exprType, ColumnType.nullType))
+          ...explodedCastAs(f, as._expressions.$6.$exprType)
         else
           f,
-        if (g._type is _ExprType<Null>)
-          ..._NullExprType._explodedCastAs(g, as._expressions.$7._type)
+        if (identical(g.$exprType, ColumnType.nullType))
+          ...explodedCastAs(g, as._expressions.$7.$exprType)
         else
           g,
-        if (h._type is _ExprType<Null>)
-          ..._NullExprType._explodedCastAs(h, as._expressions.$8._type)
+        if (identical(h.$exprType, ColumnType.nullType))
+          ...explodedCastAs(h, as._expressions.$8.$exprType)
         else
           h,
       ],
     );
-    return SelectFromClause._(_from(_expressions.toList()), handle, projection);
+    return SelectFromClause.internal(
+      _from(_expressions.toList()),
+      handle,
+      projection,
+    );
   }
 
   /// Combine this [Query] with [other] using `UNION` _set operator_.
@@ -7307,7 +7470,8 @@ extension Query8<A, B, C, D, E, F, G, H>
   ) => Query._(
     _context,
     _expressions,
-    (e) => UnionClause._(_from(_expressions.toList()), other._castAs(this)),
+    (e) =>
+        UnionClause.internal(_from(_expressions.toList()), other._castAs(this)),
   );
 
   /// Combine this [Query] with [other] using `UNION ALL` _set operator_.
@@ -7325,7 +7489,10 @@ extension Query8<A, B, C, D, E, F, G, H>
   ) => Query._(
     _context,
     _expressions,
-    (e) => UnionAllClause._(_from(_expressions.toList()), other._castAs(this)),
+    (e) => UnionAllClause.internal(
+      _from(_expressions.toList()),
+      other._castAs(this),
+    ),
   );
 
   /// Combine this [Query] with [other] using `INTERSECT` _set operator_.
@@ -7343,7 +7510,10 @@ extension Query8<A, B, C, D, E, F, G, H>
   ) => Query._(
     _context,
     _expressions,
-    (e) => IntersectClause._(_from(_expressions.toList()), other._castAs(this)),
+    (e) => IntersectClause.internal(
+      _from(_expressions.toList()),
+      other._castAs(this),
+    ),
   );
 
   /// Combine this [Query] with [other] using `EXCEPT` _set operator_.
@@ -7362,7 +7532,10 @@ extension Query8<A, B, C, D, E, F, G, H>
   ) => Query._(
     _context,
     _expressions,
-    (e) => ExceptClause._(_from(_expressions.toList()), other._castAs(this)),
+    (e) => ExceptClause.internal(
+      _from(_expressions.toList()),
+      other._castAs(this),
+    ),
   );
 
   /// Combine this [Query] with [other] using `UNION` _set operator_.
@@ -7458,15 +7631,15 @@ extension Query8<A, B, C, D, E, F, G, H>
   /// Query the database for rows in this [Query] as a [Stream].
   Stream<(A, B, C, D, E, F, G, H)> stream() async* {
     final from = _from(_expressions.toList());
-    final decode1 = _expressions.$1._decode;
-    final decode2 = _expressions.$2._decode;
-    final decode3 = _expressions.$3._decode;
-    final decode4 = _expressions.$4._decode;
-    final decode5 = _expressions.$5._decode;
-    final decode6 = _expressions.$6._decode;
-    final decode7 = _expressions.$7._decode;
-    final decode8 = _expressions.$8._decode;
-    final task = _context._dialect.select(SelectStatement._(from));
+    final decode1 = _expressions.$1.$decode;
+    final decode2 = _expressions.$2.$decode;
+    final decode3 = _expressions.$3.$decode;
+    final decode4 = _expressions.$4.$decode;
+    final decode5 = _expressions.$5.$decode;
+    final decode6 = _expressions.$6.$decode;
+    final decode7 = _expressions.$7.$decode;
+    final decode8 = _expressions.$8.$decode;
+    final task = _context._dialect.select(SelectStatement.internal(from));
     await for (final row in _context._query(task)) {
       yield (
         decode1(row) as A,
@@ -7517,21 +7690,21 @@ extension SubQuery8<A, B, C, D, E, F, G, H>
   ) {
     final handle = Object();
     var offset = 0;
-    final a = _expressions.$1._standin(offset, handle);
-    offset += _expressions.$1._columns;
-    final b = _expressions.$2._standin(offset, handle);
-    offset += _expressions.$2._columns;
-    final c = _expressions.$3._standin(offset, handle);
-    offset += _expressions.$3._columns;
-    final d = _expressions.$4._standin(offset, handle);
-    offset += _expressions.$4._columns;
-    final e = _expressions.$5._standin(offset, handle);
-    offset += _expressions.$5._columns;
-    final f = _expressions.$6._standin(offset, handle);
-    offset += _expressions.$6._columns;
-    final g = _expressions.$7._standin(offset, handle);
-    offset += _expressions.$7._columns;
-    final h = _expressions.$8._standin(offset, handle);
+    final a = _expressions.$1.$standin(offset, handle);
+    offset += _expressions.$1.$columnCount;
+    final b = _expressions.$2.$standin(offset, handle);
+    offset += _expressions.$2.$columnCount;
+    final c = _expressions.$3.$standin(offset, handle);
+    offset += _expressions.$3.$columnCount;
+    final d = _expressions.$4.$standin(offset, handle);
+    offset += _expressions.$4.$columnCount;
+    final e = _expressions.$5.$standin(offset, handle);
+    offset += _expressions.$5.$columnCount;
+    final f = _expressions.$6.$standin(offset, handle);
+    offset += _expressions.$6.$columnCount;
+    final g = _expressions.$7.$standin(offset, handle);
+    offset += _expressions.$7.$columnCount;
+    final h = _expressions.$8.$standin(offset, handle);
     return (handle, builder(a, b, c, d, e, f, g, h));
   }
 
@@ -7558,7 +7731,7 @@ extension SubQuery8<A, B, C, D, E, F, G, H>
     final (handle, where) = _build(conditionBuilder);
     return SubQuery._(
       _expressions,
-      (e) => WhereClause._(_from(e), handle, where),
+      (e) => WhereClause.internal(_from(e), handle, where),
     );
   }
 
@@ -7609,7 +7782,7 @@ extension SubQuery8<A, B, C, D, E, F, G, H>
     return OrderedSubQuery._(
       SubQuery._(
         _expressions,
-        (e) => OrderByClause._(_from(e), handle, orderBy),
+        (e) => OrderByClause.internal(_from(e), handle, orderBy),
       ),
     );
   }
@@ -7621,7 +7794,7 @@ extension SubQuery8<A, B, C, D, E, F, G, H>
     (Expr<A>, Expr<B>, Expr<C>, Expr<D>, Expr<E>, Expr<F>, Expr<G>, Expr<H>)
   >
   limit(int limit) =>
-      SubQuery._(_expressions, (e) => LimitClause._(_from(e), limit));
+      SubQuery._(_expressions, (e) => LimitClause.internal(_from(e), limit));
 
   /// Offset [SubQuery] using `OFFSET` clause.
   ///
@@ -7630,7 +7803,7 @@ extension SubQuery8<A, B, C, D, E, F, G, H>
     (Expr<A>, Expr<B>, Expr<C>, Expr<D>, Expr<E>, Expr<F>, Expr<G>, Expr<H>)
   >
   offset(int offset) =>
-      SubQuery._(_expressions, (e) => OffsetClause._(_from(e), offset));
+      SubQuery._(_expressions, (e) => OffsetClause.internal(_from(e), offset));
 
   /// Count number of rows in this [SubQuery] using `COUNT(*)` aggregate
   /// function.
@@ -7642,7 +7815,7 @@ extension SubQuery8<A, B, C, D, E, F, G, H>
   /// don't wish to count `null` values, use [where] to filter out such
   /// rows first.
   Expr<int> count() => select(
-    (a, b, c, d, e, f, g, h) => (CountAllExpression._(),),
+    (a, b, c, d, e, f, g, h) => (CountAllExpression.internal(),),
   ).first.asNotNull();
 
   /// Create a projection of this [SubQuery] using `SELECT` clause.
@@ -7670,7 +7843,7 @@ extension SubQuery8<A, B, C, D, E, F, G, H>
     final (handle, projection) = _build(projectionBuilder);
     return SubQuery._(
       projection,
-      (e) => SelectFromClause._(_from(_expressions.toList()), handle, e),
+      (e) => SelectFromClause.internal(_from(_expressions.toList()), handle, e),
     );
   }
 
@@ -7678,7 +7851,8 @@ extension SubQuery8<A, B, C, D, E, F, G, H>
   ///
   /// This returns an [Expr<bool>] that evaluates to `true`, if this [SubQuery]
   /// contains any rows, even if those rows are entirely `null`s.
-  Expr<bool> exists() => ExistsExpression._(_from(_expressions.toList()));
+  Expr<bool> exists() =>
+      ExistsExpression.internal(_from(_expressions.toList()));
 }
 
 /// Extension methods for a query returning zero or more rows with
@@ -8471,7 +8645,7 @@ extension InnerJoin1On1<A, B> on InnerJoin<(Expr<A>,), (Expr<B>,)> {
   Query<(Expr<A>, Expr<B>)> get all => Query._(
     _from._context,
     (_from._expressions.$1, _join._expressions.$1),
-    (_) => JoinClause._(
+    (_) => JoinClause.internal(
       Object(),
       JoinType.inner,
       _from._from(_from._expressions.toList()),
@@ -8490,7 +8664,7 @@ extension InnerJoin1On1<A, B> on InnerJoin<(Expr<A>,), (Expr<B>,)> {
       _join._expressions.$1,
     ), (_) => join);
     final (handle, on) = q._build(conditionBuilder);
-    join = JoinClause._(
+    join = JoinClause.internal(
       handle,
       JoinType.inner,
       _from._from(_from._expressions.toList()),
@@ -8513,7 +8687,7 @@ extension LeftJoin1On1<A, B> on LeftJoin<(Expr<A>,), (Expr<B>,)> {
       _join._expressions.$1,
     ), (_) => join);
     final (handle, on) = q._build(conditionBuilder);
-    join = JoinClause._(
+    join = JoinClause.internal(
       handle,
       JoinType.left,
       _from._from(_from._expressions.toList()),
@@ -8536,7 +8710,7 @@ extension RightJoin1On1<A, B> on RightJoin<(Expr<A>,), (Expr<B>,)> {
       _join._expressions.$1,
     ), (_) => join);
     final (handle, on) = q._build(conditionBuilder);
-    join = JoinClause._(
+    join = JoinClause.internal(
       handle,
       JoinType.right,
       _from._from(_from._expressions.toList()),
@@ -8555,7 +8729,7 @@ extension InnerJoin1On2<A, B, C> on InnerJoin<(Expr<A>,), (Expr<B>, Expr<C>)> {
   Query<(Expr<A>, Expr<B>, Expr<C>)> get all => Query._(
     _from._context,
     (_from._expressions.$1, _join._expressions.$1, _join._expressions.$2),
-    (_) => JoinClause._(
+    (_) => JoinClause.internal(
       Object(),
       JoinType.inner,
       _from._from(_from._expressions.toList()),
@@ -8575,7 +8749,7 @@ extension InnerJoin1On2<A, B, C> on InnerJoin<(Expr<A>,), (Expr<B>, Expr<C>)> {
       _join._expressions.$2,
     ), (_) => join);
     final (handle, on) = q._build(conditionBuilder);
-    join = JoinClause._(
+    join = JoinClause.internal(
       handle,
       JoinType.inner,
       _from._from(_from._expressions.toList()),
@@ -8599,7 +8773,7 @@ extension LeftJoin1On2<A, B, C> on LeftJoin<(Expr<A>,), (Expr<B>, Expr<C>)> {
       _join._expressions.$2,
     ), (_) => join);
     final (handle, on) = q._build(conditionBuilder);
-    join = JoinClause._(
+    join = JoinClause.internal(
       handle,
       JoinType.left,
       _from._from(_from._expressions.toList()),
@@ -8623,7 +8797,7 @@ extension RightJoin1On2<A, B, C> on RightJoin<(Expr<A>,), (Expr<B>, Expr<C>)> {
       _join._expressions.$2,
     ), (_) => join);
     final (handle, on) = q._build(conditionBuilder);
-    join = JoinClause._(
+    join = JoinClause.internal(
       handle,
       JoinType.right,
       _from._from(_from._expressions.toList()),
@@ -8648,7 +8822,7 @@ extension InnerJoin1On3<A, B, C, D>
       _join._expressions.$2,
       _join._expressions.$3,
     ),
-    (_) => JoinClause._(
+    (_) => JoinClause.internal(
       Object(),
       JoinType.inner,
       _from._from(_from._expressions.toList()),
@@ -8670,7 +8844,7 @@ extension InnerJoin1On3<A, B, C, D>
       _join._expressions.$3,
     ), (_) => join);
     final (handle, on) = q._build(conditionBuilder);
-    join = JoinClause._(
+    join = JoinClause.internal(
       handle,
       JoinType.inner,
       _from._from(_from._expressions.toList()),
@@ -8697,7 +8871,7 @@ extension LeftJoin1On3<A, B, C, D>
       _join._expressions.$3,
     ), (_) => join);
     final (handle, on) = q._build(conditionBuilder);
-    join = JoinClause._(
+    join = JoinClause.internal(
       handle,
       JoinType.left,
       _from._from(_from._expressions.toList()),
@@ -8724,7 +8898,7 @@ extension RightJoin1On3<A, B, C, D>
       _join._expressions.$3,
     ), (_) => join);
     final (handle, on) = q._build(conditionBuilder);
-    join = JoinClause._(
+    join = JoinClause.internal(
       handle,
       JoinType.right,
       _from._from(_from._expressions.toList()),
@@ -8750,7 +8924,7 @@ extension InnerJoin1On4<A, B, C, D, E>
       _join._expressions.$3,
       _join._expressions.$4,
     ),
-    (_) => JoinClause._(
+    (_) => JoinClause.internal(
       Object(),
       JoinType.inner,
       _from._from(_from._expressions.toList()),
@@ -8773,7 +8947,7 @@ extension InnerJoin1On4<A, B, C, D, E>
       _join._expressions.$4,
     ), (_) => join);
     final (handle, on) = q._build(conditionBuilder);
-    join = JoinClause._(
+    join = JoinClause.internal(
       handle,
       JoinType.inner,
       _from._from(_from._expressions.toList()),
@@ -8801,7 +8975,7 @@ extension LeftJoin1On4<A, B, C, D, E>
       _join._expressions.$4,
     ), (_) => join);
     final (handle, on) = q._build(conditionBuilder);
-    join = JoinClause._(
+    join = JoinClause.internal(
       handle,
       JoinType.left,
       _from._from(_from._expressions.toList()),
@@ -8829,7 +9003,7 @@ extension RightJoin1On4<A, B, C, D, E>
       _join._expressions.$4,
     ), (_) => join);
     final (handle, on) = q._build(conditionBuilder);
-    join = JoinClause._(
+    join = JoinClause.internal(
       handle,
       JoinType.right,
       _from._from(_from._expressions.toList()),
@@ -8857,7 +9031,7 @@ extension InnerJoin1On5<A, B, C, D, E, F>
           _join._expressions.$4,
           _join._expressions.$5,
         ),
-        (_) => JoinClause._(
+        (_) => JoinClause.internal(
           Object(),
           JoinType.inner,
           _from._from(_from._expressions.toList()),
@@ -8888,7 +9062,7 @@ extension InnerJoin1On5<A, B, C, D, E, F>
       _join._expressions.$5,
     ), (_) => join);
     final (handle, on) = q._build(conditionBuilder);
-    join = JoinClause._(
+    join = JoinClause.internal(
       handle,
       JoinType.inner,
       _from._from(_from._expressions.toList()),
@@ -8924,7 +9098,7 @@ extension LeftJoin1On5<A, B, C, D, E, F>
       _join._expressions.$5,
     ), (_) => join);
     final (handle, on) = q._build(conditionBuilder);
-    join = JoinClause._(
+    join = JoinClause.internal(
       handle,
       JoinType.left,
       _from._from(_from._expressions.toList()),
@@ -8960,7 +9134,7 @@ extension RightJoin1On5<A, B, C, D, E, F>
       _join._expressions.$5,
     ), (_) => join);
     final (handle, on) = q._build(conditionBuilder);
-    join = JoinClause._(
+    join = JoinClause.internal(
       handle,
       JoinType.right,
       _from._from(_from._expressions.toList()),
@@ -8993,7 +9167,7 @@ extension InnerJoin1On6<A, B, C, D, E, F, G>
       _join._expressions.$5,
       _join._expressions.$6,
     ),
-    (_) => JoinClause._(
+    (_) => JoinClause.internal(
       Object(),
       JoinType.inner,
       _from._from(_from._expressions.toList()),
@@ -9026,7 +9200,7 @@ extension InnerJoin1On6<A, B, C, D, E, F, G>
       _join._expressions.$6,
     ), (_) => join);
     final (handle, on) = q._build(conditionBuilder);
-    join = JoinClause._(
+    join = JoinClause.internal(
       handle,
       JoinType.inner,
       _from._from(_from._expressions.toList()),
@@ -9069,7 +9243,7 @@ extension LeftJoin1On6<A, B, C, D, E, F, G>
       _join._expressions.$6,
     ), (_) => join);
     final (handle, on) = q._build(conditionBuilder);
-    join = JoinClause._(
+    join = JoinClause.internal(
       handle,
       JoinType.left,
       _from._from(_from._expressions.toList()),
@@ -9111,7 +9285,7 @@ extension RightJoin1On6<A, B, C, D, E, F, G>
       _join._expressions.$6,
     ), (_) => join);
     final (handle, on) = q._build(conditionBuilder);
-    join = JoinClause._(
+    join = JoinClause.internal(
       handle,
       JoinType.right,
       _from._from(_from._expressions.toList()),
@@ -9147,7 +9321,7 @@ extension InnerJoin1On7<A, B, C, D, E, F, G, H>
       _join._expressions.$6,
       _join._expressions.$7,
     ),
-    (_) => JoinClause._(
+    (_) => JoinClause.internal(
       Object(),
       JoinType.inner,
       _from._from(_from._expressions.toList()),
@@ -9185,7 +9359,7 @@ extension InnerJoin1On7<A, B, C, D, E, F, G, H>
       _join._expressions.$7,
     ), (_) => join);
     final (handle, on) = q._build(conditionBuilder);
-    join = JoinClause._(
+    join = JoinClause.internal(
       handle,
       JoinType.inner,
       _from._from(_from._expressions.toList()),
@@ -9241,7 +9415,7 @@ extension LeftJoin1On7<A, B, C, D, E, F, G, H>
       _join._expressions.$7,
     ), (_) => join);
     final (handle, on) = q._build(conditionBuilder);
-    join = JoinClause._(
+    join = JoinClause.internal(
       handle,
       JoinType.left,
       _from._from(_from._expressions.toList()),
@@ -9288,7 +9462,7 @@ extension RightJoin1On7<A, B, C, D, E, F, G, H>
       _join._expressions.$7,
     ), (_) => join);
     final (handle, on) = q._build(conditionBuilder);
-    join = JoinClause._(
+    join = JoinClause.internal(
       handle,
       JoinType.right,
       _from._from(_from._expressions.toList()),
@@ -9307,7 +9481,7 @@ extension InnerJoin2On1<A, B, C> on InnerJoin<(Expr<A>, Expr<B>), (Expr<C>,)> {
   Query<(Expr<A>, Expr<B>, Expr<C>)> get all => Query._(
     _from._context,
     (_from._expressions.$1, _from._expressions.$2, _join._expressions.$1),
-    (_) => JoinClause._(
+    (_) => JoinClause.internal(
       Object(),
       JoinType.inner,
       _from._from(_from._expressions.toList()),
@@ -9327,7 +9501,7 @@ extension InnerJoin2On1<A, B, C> on InnerJoin<(Expr<A>, Expr<B>), (Expr<C>,)> {
       _join._expressions.$1,
     ), (_) => join);
     final (handle, on) = q._build(conditionBuilder);
-    join = JoinClause._(
+    join = JoinClause.internal(
       handle,
       JoinType.inner,
       _from._from(_from._expressions.toList()),
@@ -9351,7 +9525,7 @@ extension LeftJoin2On1<A, B, C> on LeftJoin<(Expr<A>, Expr<B>), (Expr<C>,)> {
       _join._expressions.$1,
     ), (_) => join);
     final (handle, on) = q._build(conditionBuilder);
-    join = JoinClause._(
+    join = JoinClause.internal(
       handle,
       JoinType.left,
       _from._from(_from._expressions.toList()),
@@ -9375,7 +9549,7 @@ extension RightJoin2On1<A, B, C> on RightJoin<(Expr<A>, Expr<B>), (Expr<C>,)> {
       _join._expressions.$1,
     ), (_) => join);
     final (handle, on) = q._build(conditionBuilder);
-    join = JoinClause._(
+    join = JoinClause.internal(
       handle,
       JoinType.right,
       _from._from(_from._expressions.toList()),
@@ -9400,7 +9574,7 @@ extension InnerJoin2On2<A, B, C, D>
       _join._expressions.$1,
       _join._expressions.$2,
     ),
-    (_) => JoinClause._(
+    (_) => JoinClause.internal(
       Object(),
       JoinType.inner,
       _from._from(_from._expressions.toList()),
@@ -9422,7 +9596,7 @@ extension InnerJoin2On2<A, B, C, D>
       _join._expressions.$2,
     ), (_) => join);
     final (handle, on) = q._build(conditionBuilder);
-    join = JoinClause._(
+    join = JoinClause.internal(
       handle,
       JoinType.inner,
       _from._from(_from._expressions.toList()),
@@ -9449,7 +9623,7 @@ extension LeftJoin2On2<A, B, C, D>
       _join._expressions.$2,
     ), (_) => join);
     final (handle, on) = q._build(conditionBuilder);
-    join = JoinClause._(
+    join = JoinClause.internal(
       handle,
       JoinType.left,
       _from._from(_from._expressions.toList()),
@@ -9476,7 +9650,7 @@ extension RightJoin2On2<A, B, C, D>
       _join._expressions.$2,
     ), (_) => join);
     final (handle, on) = q._build(conditionBuilder);
-    join = JoinClause._(
+    join = JoinClause.internal(
       handle,
       JoinType.right,
       _from._from(_from._expressions.toList()),
@@ -9502,7 +9676,7 @@ extension InnerJoin2On3<A, B, C, D, E>
       _join._expressions.$2,
       _join._expressions.$3,
     ),
-    (_) => JoinClause._(
+    (_) => JoinClause.internal(
       Object(),
       JoinType.inner,
       _from._from(_from._expressions.toList()),
@@ -9525,7 +9699,7 @@ extension InnerJoin2On3<A, B, C, D, E>
       _join._expressions.$3,
     ), (_) => join);
     final (handle, on) = q._build(conditionBuilder);
-    join = JoinClause._(
+    join = JoinClause.internal(
       handle,
       JoinType.inner,
       _from._from(_from._expressions.toList()),
@@ -9553,7 +9727,7 @@ extension LeftJoin2On3<A, B, C, D, E>
       _join._expressions.$3,
     ), (_) => join);
     final (handle, on) = q._build(conditionBuilder);
-    join = JoinClause._(
+    join = JoinClause.internal(
       handle,
       JoinType.left,
       _from._from(_from._expressions.toList()),
@@ -9581,7 +9755,7 @@ extension RightJoin2On3<A, B, C, D, E>
       _join._expressions.$3,
     ), (_) => join);
     final (handle, on) = q._build(conditionBuilder);
-    join = JoinClause._(
+    join = JoinClause.internal(
       handle,
       JoinType.right,
       _from._from(_from._expressions.toList()),
@@ -9609,7 +9783,7 @@ extension InnerJoin2On4<A, B, C, D, E, F>
           _join._expressions.$3,
           _join._expressions.$4,
         ),
-        (_) => JoinClause._(
+        (_) => JoinClause.internal(
           Object(),
           JoinType.inner,
           _from._from(_from._expressions.toList()),
@@ -9640,7 +9814,7 @@ extension InnerJoin2On4<A, B, C, D, E, F>
       _join._expressions.$4,
     ), (_) => join);
     final (handle, on) = q._build(conditionBuilder);
-    join = JoinClause._(
+    join = JoinClause.internal(
       handle,
       JoinType.inner,
       _from._from(_from._expressions.toList()),
@@ -9676,7 +9850,7 @@ extension LeftJoin2On4<A, B, C, D, E, F>
       _join._expressions.$4,
     ), (_) => join);
     final (handle, on) = q._build(conditionBuilder);
-    join = JoinClause._(
+    join = JoinClause.internal(
       handle,
       JoinType.left,
       _from._from(_from._expressions.toList()),
@@ -9712,7 +9886,7 @@ extension RightJoin2On4<A, B, C, D, E, F>
       _join._expressions.$4,
     ), (_) => join);
     final (handle, on) = q._build(conditionBuilder);
-    join = JoinClause._(
+    join = JoinClause.internal(
       handle,
       JoinType.right,
       _from._from(_from._expressions.toList()),
@@ -9745,7 +9919,7 @@ extension InnerJoin2On5<A, B, C, D, E, F, G>
       _join._expressions.$4,
       _join._expressions.$5,
     ),
-    (_) => JoinClause._(
+    (_) => JoinClause.internal(
       Object(),
       JoinType.inner,
       _from._from(_from._expressions.toList()),
@@ -9778,7 +9952,7 @@ extension InnerJoin2On5<A, B, C, D, E, F, G>
       _join._expressions.$5,
     ), (_) => join);
     final (handle, on) = q._build(conditionBuilder);
-    join = JoinClause._(
+    join = JoinClause.internal(
       handle,
       JoinType.inner,
       _from._from(_from._expressions.toList()),
@@ -9821,7 +9995,7 @@ extension LeftJoin2On5<A, B, C, D, E, F, G>
       _join._expressions.$5,
     ), (_) => join);
     final (handle, on) = q._build(conditionBuilder);
-    join = JoinClause._(
+    join = JoinClause.internal(
       handle,
       JoinType.left,
       _from._from(_from._expressions.toList()),
@@ -9863,7 +10037,7 @@ extension RightJoin2On5<A, B, C, D, E, F, G>
       _join._expressions.$5,
     ), (_) => join);
     final (handle, on) = q._build(conditionBuilder);
-    join = JoinClause._(
+    join = JoinClause.internal(
       handle,
       JoinType.right,
       _from._from(_from._expressions.toList()),
@@ -9899,7 +10073,7 @@ extension InnerJoin2On6<A, B, C, D, E, F, G, H>
       _join._expressions.$5,
       _join._expressions.$6,
     ),
-    (_) => JoinClause._(
+    (_) => JoinClause.internal(
       Object(),
       JoinType.inner,
       _from._from(_from._expressions.toList()),
@@ -9937,7 +10111,7 @@ extension InnerJoin2On6<A, B, C, D, E, F, G, H>
       _join._expressions.$6,
     ), (_) => join);
     final (handle, on) = q._build(conditionBuilder);
-    join = JoinClause._(
+    join = JoinClause.internal(
       handle,
       JoinType.inner,
       _from._from(_from._expressions.toList()),
@@ -9993,7 +10167,7 @@ extension LeftJoin2On6<A, B, C, D, E, F, G, H>
       _join._expressions.$6,
     ), (_) => join);
     final (handle, on) = q._build(conditionBuilder);
-    join = JoinClause._(
+    join = JoinClause.internal(
       handle,
       JoinType.left,
       _from._from(_from._expressions.toList()),
@@ -10040,7 +10214,7 @@ extension RightJoin2On6<A, B, C, D, E, F, G, H>
       _join._expressions.$6,
     ), (_) => join);
     final (handle, on) = q._build(conditionBuilder);
-    join = JoinClause._(
+    join = JoinClause.internal(
       handle,
       JoinType.right,
       _from._from(_from._expressions.toList()),
@@ -10065,7 +10239,7 @@ extension InnerJoin3On1<A, B, C, D>
       _from._expressions.$3,
       _join._expressions.$1,
     ),
-    (_) => JoinClause._(
+    (_) => JoinClause.internal(
       Object(),
       JoinType.inner,
       _from._from(_from._expressions.toList()),
@@ -10087,7 +10261,7 @@ extension InnerJoin3On1<A, B, C, D>
       _join._expressions.$1,
     ), (_) => join);
     final (handle, on) = q._build(conditionBuilder);
-    join = JoinClause._(
+    join = JoinClause.internal(
       handle,
       JoinType.inner,
       _from._from(_from._expressions.toList()),
@@ -10114,7 +10288,7 @@ extension LeftJoin3On1<A, B, C, D>
       _join._expressions.$1,
     ), (_) => join);
     final (handle, on) = q._build(conditionBuilder);
-    join = JoinClause._(
+    join = JoinClause.internal(
       handle,
       JoinType.left,
       _from._from(_from._expressions.toList()),
@@ -10141,7 +10315,7 @@ extension RightJoin3On1<A, B, C, D>
       _join._expressions.$1,
     ), (_) => join);
     final (handle, on) = q._build(conditionBuilder);
-    join = JoinClause._(
+    join = JoinClause.internal(
       handle,
       JoinType.right,
       _from._from(_from._expressions.toList()),
@@ -10167,7 +10341,7 @@ extension InnerJoin3On2<A, B, C, D, E>
       _join._expressions.$1,
       _join._expressions.$2,
     ),
-    (_) => JoinClause._(
+    (_) => JoinClause.internal(
       Object(),
       JoinType.inner,
       _from._from(_from._expressions.toList()),
@@ -10190,7 +10364,7 @@ extension InnerJoin3On2<A, B, C, D, E>
       _join._expressions.$2,
     ), (_) => join);
     final (handle, on) = q._build(conditionBuilder);
-    join = JoinClause._(
+    join = JoinClause.internal(
       handle,
       JoinType.inner,
       _from._from(_from._expressions.toList()),
@@ -10218,7 +10392,7 @@ extension LeftJoin3On2<A, B, C, D, E>
       _join._expressions.$2,
     ), (_) => join);
     final (handle, on) = q._build(conditionBuilder);
-    join = JoinClause._(
+    join = JoinClause.internal(
       handle,
       JoinType.left,
       _from._from(_from._expressions.toList()),
@@ -10246,7 +10420,7 @@ extension RightJoin3On2<A, B, C, D, E>
       _join._expressions.$2,
     ), (_) => join);
     final (handle, on) = q._build(conditionBuilder);
-    join = JoinClause._(
+    join = JoinClause.internal(
       handle,
       JoinType.right,
       _from._from(_from._expressions.toList()),
@@ -10274,7 +10448,7 @@ extension InnerJoin3On3<A, B, C, D, E, F>
           _join._expressions.$2,
           _join._expressions.$3,
         ),
-        (_) => JoinClause._(
+        (_) => JoinClause.internal(
           Object(),
           JoinType.inner,
           _from._from(_from._expressions.toList()),
@@ -10305,7 +10479,7 @@ extension InnerJoin3On3<A, B, C, D, E, F>
       _join._expressions.$3,
     ), (_) => join);
     final (handle, on) = q._build(conditionBuilder);
-    join = JoinClause._(
+    join = JoinClause.internal(
       handle,
       JoinType.inner,
       _from._from(_from._expressions.toList()),
@@ -10341,7 +10515,7 @@ extension LeftJoin3On3<A, B, C, D, E, F>
       _join._expressions.$3,
     ), (_) => join);
     final (handle, on) = q._build(conditionBuilder);
-    join = JoinClause._(
+    join = JoinClause.internal(
       handle,
       JoinType.left,
       _from._from(_from._expressions.toList()),
@@ -10377,7 +10551,7 @@ extension RightJoin3On3<A, B, C, D, E, F>
       _join._expressions.$3,
     ), (_) => join);
     final (handle, on) = q._build(conditionBuilder);
-    join = JoinClause._(
+    join = JoinClause.internal(
       handle,
       JoinType.right,
       _from._from(_from._expressions.toList()),
@@ -10410,7 +10584,7 @@ extension InnerJoin3On4<A, B, C, D, E, F, G>
       _join._expressions.$3,
       _join._expressions.$4,
     ),
-    (_) => JoinClause._(
+    (_) => JoinClause.internal(
       Object(),
       JoinType.inner,
       _from._from(_from._expressions.toList()),
@@ -10443,7 +10617,7 @@ extension InnerJoin3On4<A, B, C, D, E, F, G>
       _join._expressions.$4,
     ), (_) => join);
     final (handle, on) = q._build(conditionBuilder);
-    join = JoinClause._(
+    join = JoinClause.internal(
       handle,
       JoinType.inner,
       _from._from(_from._expressions.toList()),
@@ -10485,7 +10659,7 @@ extension LeftJoin3On4<A, B, C, D, E, F, G>
       _join._expressions.$4,
     ), (_) => join);
     final (handle, on) = q._build(conditionBuilder);
-    join = JoinClause._(
+    join = JoinClause.internal(
       handle,
       JoinType.left,
       _from._from(_from._expressions.toList()),
@@ -10527,7 +10701,7 @@ extension RightJoin3On4<A, B, C, D, E, F, G>
       _join._expressions.$4,
     ), (_) => join);
     final (handle, on) = q._build(conditionBuilder);
-    join = JoinClause._(
+    join = JoinClause.internal(
       handle,
       JoinType.right,
       _from._from(_from._expressions.toList()),
@@ -10563,7 +10737,7 @@ extension InnerJoin3On5<A, B, C, D, E, F, G, H>
       _join._expressions.$4,
       _join._expressions.$5,
     ),
-    (_) => JoinClause._(
+    (_) => JoinClause.internal(
       Object(),
       JoinType.inner,
       _from._from(_from._expressions.toList()),
@@ -10601,7 +10775,7 @@ extension InnerJoin3On5<A, B, C, D, E, F, G, H>
       _join._expressions.$5,
     ), (_) => join);
     final (handle, on) = q._build(conditionBuilder);
-    join = JoinClause._(
+    join = JoinClause.internal(
       handle,
       JoinType.inner,
       _from._from(_from._expressions.toList()),
@@ -10657,7 +10831,7 @@ extension LeftJoin3On5<A, B, C, D, E, F, G, H>
       _join._expressions.$5,
     ), (_) => join);
     final (handle, on) = q._build(conditionBuilder);
-    join = JoinClause._(
+    join = JoinClause.internal(
       handle,
       JoinType.left,
       _from._from(_from._expressions.toList()),
@@ -10704,7 +10878,7 @@ extension RightJoin3On5<A, B, C, D, E, F, G, H>
       _join._expressions.$5,
     ), (_) => join);
     final (handle, on) = q._build(conditionBuilder);
-    join = JoinClause._(
+    join = JoinClause.internal(
       handle,
       JoinType.right,
       _from._from(_from._expressions.toList()),
@@ -10730,7 +10904,7 @@ extension InnerJoin4On1<A, B, C, D, E>
       _from._expressions.$4,
       _join._expressions.$1,
     ),
-    (_) => JoinClause._(
+    (_) => JoinClause.internal(
       Object(),
       JoinType.inner,
       _from._from(_from._expressions.toList()),
@@ -10753,7 +10927,7 @@ extension InnerJoin4On1<A, B, C, D, E>
       _join._expressions.$1,
     ), (_) => join);
     final (handle, on) = q._build(conditionBuilder);
-    join = JoinClause._(
+    join = JoinClause.internal(
       handle,
       JoinType.inner,
       _from._from(_from._expressions.toList()),
@@ -10781,7 +10955,7 @@ extension LeftJoin4On1<A, B, C, D, E>
       _join._expressions.$1,
     ), (_) => join);
     final (handle, on) = q._build(conditionBuilder);
-    join = JoinClause._(
+    join = JoinClause.internal(
       handle,
       JoinType.left,
       _from._from(_from._expressions.toList()),
@@ -10809,7 +10983,7 @@ extension RightJoin4On1<A, B, C, D, E>
       _join._expressions.$1,
     ), (_) => join);
     final (handle, on) = q._build(conditionBuilder);
-    join = JoinClause._(
+    join = JoinClause.internal(
       handle,
       JoinType.right,
       _from._from(_from._expressions.toList()),
@@ -10837,7 +11011,7 @@ extension InnerJoin4On2<A, B, C, D, E, F>
           _join._expressions.$1,
           _join._expressions.$2,
         ),
-        (_) => JoinClause._(
+        (_) => JoinClause.internal(
           Object(),
           JoinType.inner,
           _from._from(_from._expressions.toList()),
@@ -10868,7 +11042,7 @@ extension InnerJoin4On2<A, B, C, D, E, F>
       _join._expressions.$2,
     ), (_) => join);
     final (handle, on) = q._build(conditionBuilder);
-    join = JoinClause._(
+    join = JoinClause.internal(
       handle,
       JoinType.inner,
       _from._from(_from._expressions.toList()),
@@ -10904,7 +11078,7 @@ extension LeftJoin4On2<A, B, C, D, E, F>
       _join._expressions.$2,
     ), (_) => join);
     final (handle, on) = q._build(conditionBuilder);
-    join = JoinClause._(
+    join = JoinClause.internal(
       handle,
       JoinType.left,
       _from._from(_from._expressions.toList()),
@@ -10940,7 +11114,7 @@ extension RightJoin4On2<A, B, C, D, E, F>
       _join._expressions.$2,
     ), (_) => join);
     final (handle, on) = q._build(conditionBuilder);
-    join = JoinClause._(
+    join = JoinClause.internal(
       handle,
       JoinType.right,
       _from._from(_from._expressions.toList()),
@@ -10973,7 +11147,7 @@ extension InnerJoin4On3<A, B, C, D, E, F, G>
       _join._expressions.$2,
       _join._expressions.$3,
     ),
-    (_) => JoinClause._(
+    (_) => JoinClause.internal(
       Object(),
       JoinType.inner,
       _from._from(_from._expressions.toList()),
@@ -11006,7 +11180,7 @@ extension InnerJoin4On3<A, B, C, D, E, F, G>
       _join._expressions.$3,
     ), (_) => join);
     final (handle, on) = q._build(conditionBuilder);
-    join = JoinClause._(
+    join = JoinClause.internal(
       handle,
       JoinType.inner,
       _from._from(_from._expressions.toList()),
@@ -11048,7 +11222,7 @@ extension LeftJoin4On3<A, B, C, D, E, F, G>
       _join._expressions.$3,
     ), (_) => join);
     final (handle, on) = q._build(conditionBuilder);
-    join = JoinClause._(
+    join = JoinClause.internal(
       handle,
       JoinType.left,
       _from._from(_from._expressions.toList()),
@@ -11090,7 +11264,7 @@ extension RightJoin4On3<A, B, C, D, E, F, G>
       _join._expressions.$3,
     ), (_) => join);
     final (handle, on) = q._build(conditionBuilder);
-    join = JoinClause._(
+    join = JoinClause.internal(
       handle,
       JoinType.right,
       _from._from(_from._expressions.toList()),
@@ -11126,7 +11300,7 @@ extension InnerJoin4On4<A, B, C, D, E, F, G, H>
       _join._expressions.$3,
       _join._expressions.$4,
     ),
-    (_) => JoinClause._(
+    (_) => JoinClause.internal(
       Object(),
       JoinType.inner,
       _from._from(_from._expressions.toList()),
@@ -11164,7 +11338,7 @@ extension InnerJoin4On4<A, B, C, D, E, F, G, H>
       _join._expressions.$4,
     ), (_) => join);
     final (handle, on) = q._build(conditionBuilder);
-    join = JoinClause._(
+    join = JoinClause.internal(
       handle,
       JoinType.inner,
       _from._from(_from._expressions.toList()),
@@ -11211,7 +11385,7 @@ extension LeftJoin4On4<A, B, C, D, E, F, G, H>
       _join._expressions.$4,
     ), (_) => join);
     final (handle, on) = q._build(conditionBuilder);
-    join = JoinClause._(
+    join = JoinClause.internal(
       handle,
       JoinType.left,
       _from._from(_from._expressions.toList()),
@@ -11258,7 +11432,7 @@ extension RightJoin4On4<A, B, C, D, E, F, G, H>
       _join._expressions.$4,
     ), (_) => join);
     final (handle, on) = q._build(conditionBuilder);
-    join = JoinClause._(
+    join = JoinClause.internal(
       handle,
       JoinType.right,
       _from._from(_from._expressions.toList()),
@@ -11286,7 +11460,7 @@ extension InnerJoin5On1<A, B, C, D, E, F>
           _from._expressions.$5,
           _join._expressions.$1,
         ),
-        (_) => JoinClause._(
+        (_) => JoinClause.internal(
           Object(),
           JoinType.inner,
           _from._from(_from._expressions.toList()),
@@ -11317,7 +11491,7 @@ extension InnerJoin5On1<A, B, C, D, E, F>
       _join._expressions.$1,
     ), (_) => join);
     final (handle, on) = q._build(conditionBuilder);
-    join = JoinClause._(
+    join = JoinClause.internal(
       handle,
       JoinType.inner,
       _from._from(_from._expressions.toList()),
@@ -11353,7 +11527,7 @@ extension LeftJoin5On1<A, B, C, D, E, F>
       _join._expressions.$1,
     ), (_) => join);
     final (handle, on) = q._build(conditionBuilder);
-    join = JoinClause._(
+    join = JoinClause.internal(
       handle,
       JoinType.left,
       _from._from(_from._expressions.toList()),
@@ -11389,7 +11563,7 @@ extension RightJoin5On1<A, B, C, D, E, F>
       _join._expressions.$1,
     ), (_) => join);
     final (handle, on) = q._build(conditionBuilder);
-    join = JoinClause._(
+    join = JoinClause.internal(
       handle,
       JoinType.right,
       _from._from(_from._expressions.toList()),
@@ -11422,7 +11596,7 @@ extension InnerJoin5On2<A, B, C, D, E, F, G>
       _join._expressions.$1,
       _join._expressions.$2,
     ),
-    (_) => JoinClause._(
+    (_) => JoinClause.internal(
       Object(),
       JoinType.inner,
       _from._from(_from._expressions.toList()),
@@ -11455,7 +11629,7 @@ extension InnerJoin5On2<A, B, C, D, E, F, G>
       _join._expressions.$2,
     ), (_) => join);
     final (handle, on) = q._build(conditionBuilder);
-    join = JoinClause._(
+    join = JoinClause.internal(
       handle,
       JoinType.inner,
       _from._from(_from._expressions.toList()),
@@ -11497,7 +11671,7 @@ extension LeftJoin5On2<A, B, C, D, E, F, G>
       _join._expressions.$2,
     ), (_) => join);
     final (handle, on) = q._build(conditionBuilder);
-    join = JoinClause._(
+    join = JoinClause.internal(
       handle,
       JoinType.left,
       _from._from(_from._expressions.toList()),
@@ -11540,7 +11714,7 @@ extension RightJoin5On2<A, B, C, D, E, F, G>
       _join._expressions.$2,
     ), (_) => join);
     final (handle, on) = q._build(conditionBuilder);
-    join = JoinClause._(
+    join = JoinClause.internal(
       handle,
       JoinType.right,
       _from._from(_from._expressions.toList()),
@@ -11576,7 +11750,7 @@ extension InnerJoin5On3<A, B, C, D, E, F, G, H>
       _join._expressions.$2,
       _join._expressions.$3,
     ),
-    (_) => JoinClause._(
+    (_) => JoinClause.internal(
       Object(),
       JoinType.inner,
       _from._from(_from._expressions.toList()),
@@ -11614,7 +11788,7 @@ extension InnerJoin5On3<A, B, C, D, E, F, G, H>
       _join._expressions.$3,
     ), (_) => join);
     final (handle, on) = q._build(conditionBuilder);
-    join = JoinClause._(
+    join = JoinClause.internal(
       handle,
       JoinType.inner,
       _from._from(_from._expressions.toList()),
@@ -11661,7 +11835,7 @@ extension LeftJoin5On3<A, B, C, D, E, F, G, H>
       _join._expressions.$3,
     ), (_) => join);
     final (handle, on) = q._build(conditionBuilder);
-    join = JoinClause._(
+    join = JoinClause.internal(
       handle,
       JoinType.left,
       _from._from(_from._expressions.toList()),
@@ -11717,7 +11891,7 @@ extension RightJoin5On3<A, B, C, D, E, F, G, H>
       _join._expressions.$3,
     ), (_) => join);
     final (handle, on) = q._build(conditionBuilder);
-    join = JoinClause._(
+    join = JoinClause.internal(
       handle,
       JoinType.right,
       _from._from(_from._expressions.toList()),
@@ -11750,7 +11924,7 @@ extension InnerJoin6On1<A, B, C, D, E, F, G>
       _from._expressions.$6,
       _join._expressions.$1,
     ),
-    (_) => JoinClause._(
+    (_) => JoinClause.internal(
       Object(),
       JoinType.inner,
       _from._from(_from._expressions.toList()),
@@ -11783,7 +11957,7 @@ extension InnerJoin6On1<A, B, C, D, E, F, G>
       _join._expressions.$1,
     ), (_) => join);
     final (handle, on) = q._build(conditionBuilder);
-    join = JoinClause._(
+    join = JoinClause.internal(
       handle,
       JoinType.inner,
       _from._from(_from._expressions.toList()),
@@ -11825,7 +11999,7 @@ extension LeftJoin6On1<A, B, C, D, E, F, G>
       _join._expressions.$1,
     ), (_) => join);
     final (handle, on) = q._build(conditionBuilder);
-    join = JoinClause._(
+    join = JoinClause.internal(
       handle,
       JoinType.left,
       _from._from(_from._expressions.toList()),
@@ -11868,7 +12042,7 @@ extension RightJoin6On1<A, B, C, D, E, F, G>
       _join._expressions.$1,
     ), (_) => join);
     final (handle, on) = q._build(conditionBuilder);
-    join = JoinClause._(
+    join = JoinClause.internal(
       handle,
       JoinType.right,
       _from._from(_from._expressions.toList()),
@@ -11904,7 +12078,7 @@ extension InnerJoin6On2<A, B, C, D, E, F, G, H>
       _join._expressions.$1,
       _join._expressions.$2,
     ),
-    (_) => JoinClause._(
+    (_) => JoinClause.internal(
       Object(),
       JoinType.inner,
       _from._from(_from._expressions.toList()),
@@ -11942,7 +12116,7 @@ extension InnerJoin6On2<A, B, C, D, E, F, G, H>
       _join._expressions.$2,
     ), (_) => join);
     final (handle, on) = q._build(conditionBuilder);
-    join = JoinClause._(
+    join = JoinClause.internal(
       handle,
       JoinType.inner,
       _from._from(_from._expressions.toList()),
@@ -11989,7 +12163,7 @@ extension LeftJoin6On2<A, B, C, D, E, F, G, H>
       _join._expressions.$2,
     ), (_) => join);
     final (handle, on) = q._build(conditionBuilder);
-    join = JoinClause._(
+    join = JoinClause.internal(
       handle,
       JoinType.left,
       _from._from(_from._expressions.toList()),
@@ -12045,7 +12219,7 @@ extension RightJoin6On2<A, B, C, D, E, F, G, H>
       _join._expressions.$2,
     ), (_) => join);
     final (handle, on) = q._build(conditionBuilder);
-    join = JoinClause._(
+    join = JoinClause.internal(
       handle,
       JoinType.right,
       _from._from(_from._expressions.toList()),
@@ -12081,7 +12255,7 @@ extension InnerJoin7On1<A, B, C, D, E, F, G, H>
       _from._expressions.$7,
       _join._expressions.$1,
     ),
-    (_) => JoinClause._(
+    (_) => JoinClause.internal(
       Object(),
       JoinType.inner,
       _from._from(_from._expressions.toList()),
@@ -12119,7 +12293,7 @@ extension InnerJoin7On1<A, B, C, D, E, F, G, H>
       _join._expressions.$1,
     ), (_) => join);
     final (handle, on) = q._build(conditionBuilder);
-    join = JoinClause._(
+    join = JoinClause.internal(
       handle,
       JoinType.inner,
       _from._from(_from._expressions.toList()),
@@ -12166,7 +12340,7 @@ extension LeftJoin7On1<A, B, C, D, E, F, G, H>
       _join._expressions.$1,
     ), (_) => join);
     final (handle, on) = q._build(conditionBuilder);
-    join = JoinClause._(
+    join = JoinClause.internal(
       handle,
       JoinType.left,
       _from._from(_from._expressions.toList()),
@@ -12222,7 +12396,7 @@ extension RightJoin7On1<A, B, C, D, E, F, G, H>
       _join._expressions.$1,
     ), (_) => join);
     final (handle, on) = q._build(conditionBuilder);
-    join = JoinClause._(
+    join = JoinClause.internal(
       handle,
       JoinType.right,
       _from._from(_from._expressions.toList()),
@@ -12253,7 +12427,7 @@ extension Group1By1<A, B> on Group<(Expr<A>,), (Expr<B>,)> {
     return Query._(
       _from._context,
       agg._projection,
-      (e) => GroupByClause._(
+      (e) => GroupByClause.internal(
         _from._from(_from._expressions.toList()),
         _handle,
         e.take(1).toList(),
@@ -12283,7 +12457,7 @@ extension Aggregate1Project1<A, B> on Aggregation<(Expr<A>,), (Expr<B>,)> {
   /// to `NULL` it will coalesced to zero.
   Aggregation<(Expr<A>,), (Expr<B>, Expr<C>)> sum<C extends num>(
     Expr<C?> Function(Expr<A> a) aggregateBuilder,
-  ) => _build(aggregateBuilder, SumExpression._);
+  ) => _build(aggregateBuilder, SumExpression.internal);
 
   /// Add a `AVG` aggregate function to this [Aggregation].
   ///
@@ -12300,7 +12474,7 @@ extension Aggregate1Project1<A, B> on Aggregation<(Expr<A>,), (Expr<B>,)> {
   /// > `.orElseValue(0)` to force a non-nullable expression.
   Aggregation<(Expr<A>,), (Expr<B>, Expr<double?>)> avg<C extends num>(
     Expr<C?> Function(Expr<A> a) aggregateBuilder,
-  ) => _build(aggregateBuilder, AvgExpression._);
+  ) => _build(aggregateBuilder, AvgExpression.internal);
 
   /// Add a `MIN` aggregate function to this [Aggregation].
   ///
@@ -12313,7 +12487,7 @@ extension Aggregate1Project1<A, B> on Aggregation<(Expr<A>,), (Expr<B>,)> {
   /// the `MIN` aggregate function will return `NULL`.
   Aggregation<(Expr<A>,), (Expr<B>, Expr<C?>)> min<C extends Comparable>(
     Expr<C?> Function(Expr<A> a) aggregateBuilder,
-  ) => _build(aggregateBuilder, MinExpression._);
+  ) => _build(aggregateBuilder, MinExpression.internal);
 
   /// Add a `MAX` aggregate function to this [Aggregation].
   ///
@@ -12326,7 +12500,7 @@ extension Aggregate1Project1<A, B> on Aggregation<(Expr<A>,), (Expr<B>,)> {
   /// the `MAX` aggregate function will return `NULL`.
   Aggregation<(Expr<A>,), (Expr<B>, Expr<C?>)> max<C extends Comparable>(
     Expr<C?> Function(Expr<A> a) aggregateBuilder,
-  ) => _build(aggregateBuilder, MaxExpression._);
+  ) => _build(aggregateBuilder, MaxExpression.internal);
 
   /// Add a `COUNT(*)` aggregate function to this [Aggregation].
   ///
@@ -12337,7 +12511,7 @@ extension Aggregate1Project1<A, B> on Aggregation<(Expr<A>,), (Expr<B>,)> {
   /// This will count the number of rows in the group, including rows consisting
   /// entirely of `NULL` values.
   Aggregation<(Expr<A>,), (Expr<B>, Expr<int>)> count() =>
-      _build((a) => CountAllExpression._(), (a) => a);
+      _build((a) => CountAllExpression.internal(), (a) => a);
 }
 
 /// Extension methods for completing a `GROUP BY`.
@@ -12362,7 +12536,7 @@ extension Group2By1<A, B, C> on Group<(Expr<A>,), (Expr<B>, Expr<C>)> {
     return Query._(
       _from._context,
       agg._projection,
-      (e) => GroupByClause._(
+      (e) => GroupByClause.internal(
         _from._from(_from._expressions.toList()),
         _handle,
         e.take(1).toList(),
@@ -12394,7 +12568,7 @@ extension Aggregate1Project2<A, B, C>
   /// to `NULL` it will coalesced to zero.
   Aggregation<(Expr<A>,), (Expr<B>, Expr<C>, Expr<D>)> sum<D extends num>(
     Expr<D?> Function(Expr<A> a) aggregateBuilder,
-  ) => _build(aggregateBuilder, SumExpression._);
+  ) => _build(aggregateBuilder, SumExpression.internal);
 
   /// Add a `AVG` aggregate function to this [Aggregation].
   ///
@@ -12411,7 +12585,7 @@ extension Aggregate1Project2<A, B, C>
   /// > `.orElseValue(0)` to force a non-nullable expression.
   Aggregation<(Expr<A>,), (Expr<B>, Expr<C>, Expr<double?>)> avg<D extends num>(
     Expr<D?> Function(Expr<A> a) aggregateBuilder,
-  ) => _build(aggregateBuilder, AvgExpression._);
+  ) => _build(aggregateBuilder, AvgExpression.internal);
 
   /// Add a `MIN` aggregate function to this [Aggregation].
   ///
@@ -12424,7 +12598,7 @@ extension Aggregate1Project2<A, B, C>
   /// the `MIN` aggregate function will return `NULL`.
   Aggregation<(Expr<A>,), (Expr<B>, Expr<C>, Expr<D?>)>
   min<D extends Comparable>(Expr<D?> Function(Expr<A> a) aggregateBuilder) =>
-      _build(aggregateBuilder, MinExpression._);
+      _build(aggregateBuilder, MinExpression.internal);
 
   /// Add a `MAX` aggregate function to this [Aggregation].
   ///
@@ -12437,7 +12611,7 @@ extension Aggregate1Project2<A, B, C>
   /// the `MAX` aggregate function will return `NULL`.
   Aggregation<(Expr<A>,), (Expr<B>, Expr<C>, Expr<D?>)>
   max<D extends Comparable>(Expr<D?> Function(Expr<A> a) aggregateBuilder) =>
-      _build(aggregateBuilder, MaxExpression._);
+      _build(aggregateBuilder, MaxExpression.internal);
 
   /// Add a `COUNT(*)` aggregate function to this [Aggregation].
   ///
@@ -12448,7 +12622,7 @@ extension Aggregate1Project2<A, B, C>
   /// This will count the number of rows in the group, including rows consisting
   /// entirely of `NULL` values.
   Aggregation<(Expr<A>,), (Expr<B>, Expr<C>, Expr<int>)> count() =>
-      _build((a) => CountAllExpression._(), (a) => a);
+      _build((a) => CountAllExpression.internal(), (a) => a);
 }
 
 /// Extension methods for completing a `GROUP BY`.
@@ -12474,7 +12648,7 @@ extension Group3By1<A, B, C, D>
     return Query._(
       _from._context,
       agg._projection,
-      (e) => GroupByClause._(
+      (e) => GroupByClause.internal(
         _from._from(_from._expressions.toList()),
         _handle,
         e.take(1).toList(),
@@ -12507,7 +12681,7 @@ extension Aggregate1Project3<A, B, C, D>
   /// to `NULL` it will coalesced to zero.
   Aggregation<(Expr<A>,), (Expr<B>, Expr<C>, Expr<D>, Expr<E>)>
   sum<E extends num>(Expr<E?> Function(Expr<A> a) aggregateBuilder) =>
-      _build(aggregateBuilder, SumExpression._);
+      _build(aggregateBuilder, SumExpression.internal);
 
   /// Add a `AVG` aggregate function to this [Aggregation].
   ///
@@ -12524,7 +12698,7 @@ extension Aggregate1Project3<A, B, C, D>
   /// > `.orElseValue(0)` to force a non-nullable expression.
   Aggregation<(Expr<A>,), (Expr<B>, Expr<C>, Expr<D>, Expr<double?>)>
   avg<E extends num>(Expr<E?> Function(Expr<A> a) aggregateBuilder) =>
-      _build(aggregateBuilder, AvgExpression._);
+      _build(aggregateBuilder, AvgExpression.internal);
 
   /// Add a `MIN` aggregate function to this [Aggregation].
   ///
@@ -12537,7 +12711,7 @@ extension Aggregate1Project3<A, B, C, D>
   /// the `MIN` aggregate function will return `NULL`.
   Aggregation<(Expr<A>,), (Expr<B>, Expr<C>, Expr<D>, Expr<E?>)>
   min<E extends Comparable>(Expr<E?> Function(Expr<A> a) aggregateBuilder) =>
-      _build(aggregateBuilder, MinExpression._);
+      _build(aggregateBuilder, MinExpression.internal);
 
   /// Add a `MAX` aggregate function to this [Aggregation].
   ///
@@ -12550,7 +12724,7 @@ extension Aggregate1Project3<A, B, C, D>
   /// the `MAX` aggregate function will return `NULL`.
   Aggregation<(Expr<A>,), (Expr<B>, Expr<C>, Expr<D>, Expr<E?>)>
   max<E extends Comparable>(Expr<E?> Function(Expr<A> a) aggregateBuilder) =>
-      _build(aggregateBuilder, MaxExpression._);
+      _build(aggregateBuilder, MaxExpression.internal);
 
   /// Add a `COUNT(*)` aggregate function to this [Aggregation].
   ///
@@ -12561,7 +12735,7 @@ extension Aggregate1Project3<A, B, C, D>
   /// This will count the number of rows in the group, including rows consisting
   /// entirely of `NULL` values.
   Aggregation<(Expr<A>,), (Expr<B>, Expr<C>, Expr<D>, Expr<int>)> count() =>
-      _build((a) => CountAllExpression._(), (a) => a);
+      _build((a) => CountAllExpression.internal(), (a) => a);
 }
 
 /// Extension methods for completing a `GROUP BY`.
@@ -12587,7 +12761,7 @@ extension Group4By1<A, B, C, D, E>
     return Query._(
       _from._context,
       agg._projection,
-      (e) => GroupByClause._(
+      (e) => GroupByClause.internal(
         _from._from(_from._expressions.toList()),
         _handle,
         e.take(1).toList(),
@@ -12622,7 +12796,7 @@ extension Aggregate1Project4<A, B, C, D, E>
   /// to `NULL` it will coalesced to zero.
   Aggregation<(Expr<A>,), (Expr<B>, Expr<C>, Expr<D>, Expr<E>, Expr<F>)>
   sum<F extends num>(Expr<F?> Function(Expr<A> a) aggregateBuilder) =>
-      _build(aggregateBuilder, SumExpression._);
+      _build(aggregateBuilder, SumExpression.internal);
 
   /// Add a `AVG` aggregate function to this [Aggregation].
   ///
@@ -12639,7 +12813,7 @@ extension Aggregate1Project4<A, B, C, D, E>
   /// > `.orElseValue(0)` to force a non-nullable expression.
   Aggregation<(Expr<A>,), (Expr<B>, Expr<C>, Expr<D>, Expr<E>, Expr<double?>)>
   avg<F extends num>(Expr<F?> Function(Expr<A> a) aggregateBuilder) =>
-      _build(aggregateBuilder, AvgExpression._);
+      _build(aggregateBuilder, AvgExpression.internal);
 
   /// Add a `MIN` aggregate function to this [Aggregation].
   ///
@@ -12652,7 +12826,7 @@ extension Aggregate1Project4<A, B, C, D, E>
   /// the `MIN` aggregate function will return `NULL`.
   Aggregation<(Expr<A>,), (Expr<B>, Expr<C>, Expr<D>, Expr<E>, Expr<F?>)>
   min<F extends Comparable>(Expr<F?> Function(Expr<A> a) aggregateBuilder) =>
-      _build(aggregateBuilder, MinExpression._);
+      _build(aggregateBuilder, MinExpression.internal);
 
   /// Add a `MAX` aggregate function to this [Aggregation].
   ///
@@ -12665,7 +12839,7 @@ extension Aggregate1Project4<A, B, C, D, E>
   /// the `MAX` aggregate function will return `NULL`.
   Aggregation<(Expr<A>,), (Expr<B>, Expr<C>, Expr<D>, Expr<E>, Expr<F?>)>
   max<F extends Comparable>(Expr<F?> Function(Expr<A> a) aggregateBuilder) =>
-      _build(aggregateBuilder, MaxExpression._);
+      _build(aggregateBuilder, MaxExpression.internal);
 
   /// Add a `COUNT(*)` aggregate function to this [Aggregation].
   ///
@@ -12676,7 +12850,7 @@ extension Aggregate1Project4<A, B, C, D, E>
   /// This will count the number of rows in the group, including rows consisting
   /// entirely of `NULL` values.
   Aggregation<(Expr<A>,), (Expr<B>, Expr<C>, Expr<D>, Expr<E>, Expr<int>)>
-  count() => _build((a) => CountAllExpression._(), (a) => a);
+  count() => _build((a) => CountAllExpression.internal(), (a) => a);
 }
 
 /// Extension methods for completing a `GROUP BY`.
@@ -12703,7 +12877,7 @@ extension Group5By1<A, B, C, D, E, F>
     return Query._(
       _from._context,
       agg._projection,
-      (e) => GroupByClause._(
+      (e) => GroupByClause.internal(
         _from._from(_from._expressions.toList()),
         _handle,
         e.take(1).toList(),
@@ -12745,7 +12919,7 @@ extension Aggregate1Project5<A, B, C, D, E, F>
     (Expr<B>, Expr<C>, Expr<D>, Expr<E>, Expr<F>, Expr<G>)
   >
   sum<G extends num>(Expr<G?> Function(Expr<A> a) aggregateBuilder) =>
-      _build(aggregateBuilder, SumExpression._);
+      _build(aggregateBuilder, SumExpression.internal);
 
   /// Add a `AVG` aggregate function to this [Aggregation].
   ///
@@ -12765,7 +12939,7 @@ extension Aggregate1Project5<A, B, C, D, E, F>
     (Expr<B>, Expr<C>, Expr<D>, Expr<E>, Expr<F>, Expr<double?>)
   >
   avg<G extends num>(Expr<G?> Function(Expr<A> a) aggregateBuilder) =>
-      _build(aggregateBuilder, AvgExpression._);
+      _build(aggregateBuilder, AvgExpression.internal);
 
   /// Add a `MIN` aggregate function to this [Aggregation].
   ///
@@ -12781,7 +12955,7 @@ extension Aggregate1Project5<A, B, C, D, E, F>
     (Expr<B>, Expr<C>, Expr<D>, Expr<E>, Expr<F>, Expr<G?>)
   >
   min<G extends Comparable>(Expr<G?> Function(Expr<A> a) aggregateBuilder) =>
-      _build(aggregateBuilder, MinExpression._);
+      _build(aggregateBuilder, MinExpression.internal);
 
   /// Add a `MAX` aggregate function to this [Aggregation].
   ///
@@ -12797,7 +12971,7 @@ extension Aggregate1Project5<A, B, C, D, E, F>
     (Expr<B>, Expr<C>, Expr<D>, Expr<E>, Expr<F>, Expr<G?>)
   >
   max<G extends Comparable>(Expr<G?> Function(Expr<A> a) aggregateBuilder) =>
-      _build(aggregateBuilder, MaxExpression._);
+      _build(aggregateBuilder, MaxExpression.internal);
 
   /// Add a `COUNT(*)` aggregate function to this [Aggregation].
   ///
@@ -12811,7 +12985,7 @@ extension Aggregate1Project5<A, B, C, D, E, F>
     (Expr<A>,),
     (Expr<B>, Expr<C>, Expr<D>, Expr<E>, Expr<F>, Expr<int>)
   >
-  count() => _build((a) => CountAllExpression._(), (a) => a);
+  count() => _build((a) => CountAllExpression.internal(), (a) => a);
 }
 
 /// Extension methods for completing a `GROUP BY`.
@@ -12846,7 +13020,7 @@ extension Group6By1<A, B, C, D, E, F, G>
     return Query._(
       _from._context,
       agg._projection,
-      (e) => GroupByClause._(
+      (e) => GroupByClause.internal(
         _from._from(_from._expressions.toList()),
         _handle,
         e.take(1).toList(),
@@ -12893,7 +13067,7 @@ extension Aggregate1Project6<A, B, C, D, E, F, G>
     (Expr<B>, Expr<C>, Expr<D>, Expr<E>, Expr<F>, Expr<G>, Expr<H>)
   >
   sum<H extends num>(Expr<H?> Function(Expr<A> a) aggregateBuilder) =>
-      _build(aggregateBuilder, SumExpression._);
+      _build(aggregateBuilder, SumExpression.internal);
 
   /// Add a `AVG` aggregate function to this [Aggregation].
   ///
@@ -12913,7 +13087,7 @@ extension Aggregate1Project6<A, B, C, D, E, F, G>
     (Expr<B>, Expr<C>, Expr<D>, Expr<E>, Expr<F>, Expr<G>, Expr<double?>)
   >
   avg<H extends num>(Expr<H?> Function(Expr<A> a) aggregateBuilder) =>
-      _build(aggregateBuilder, AvgExpression._);
+      _build(aggregateBuilder, AvgExpression.internal);
 
   /// Add a `MIN` aggregate function to this [Aggregation].
   ///
@@ -12929,7 +13103,7 @@ extension Aggregate1Project6<A, B, C, D, E, F, G>
     (Expr<B>, Expr<C>, Expr<D>, Expr<E>, Expr<F>, Expr<G>, Expr<H?>)
   >
   min<H extends Comparable>(Expr<H?> Function(Expr<A> a) aggregateBuilder) =>
-      _build(aggregateBuilder, MinExpression._);
+      _build(aggregateBuilder, MinExpression.internal);
 
   /// Add a `MAX` aggregate function to this [Aggregation].
   ///
@@ -12945,7 +13119,7 @@ extension Aggregate1Project6<A, B, C, D, E, F, G>
     (Expr<B>, Expr<C>, Expr<D>, Expr<E>, Expr<F>, Expr<G>, Expr<H?>)
   >
   max<H extends Comparable>(Expr<H?> Function(Expr<A> a) aggregateBuilder) =>
-      _build(aggregateBuilder, MaxExpression._);
+      _build(aggregateBuilder, MaxExpression.internal);
 
   /// Add a `COUNT(*)` aggregate function to this [Aggregation].
   ///
@@ -12959,7 +13133,7 @@ extension Aggregate1Project6<A, B, C, D, E, F, G>
     (Expr<A>,),
     (Expr<B>, Expr<C>, Expr<D>, Expr<E>, Expr<F>, Expr<G>, Expr<int>)
   >
-  count() => _build((a) => CountAllExpression._(), (a) => a);
+  count() => _build((a) => CountAllExpression.internal(), (a) => a);
 }
 
 /// Extension methods for completing a `GROUP BY`.
@@ -12997,7 +13171,7 @@ extension Group7By1<A, B, C, D, E, F, G, H>
     return Query._(
       _from._context,
       agg._projection,
-      (e) => GroupByClause._(
+      (e) => GroupByClause.internal(
         _from._from(_from._expressions.toList()),
         _handle,
         e.take(1).toList(),
@@ -13045,7 +13219,7 @@ extension Aggregate1Project7<A, B, C, D, E, F, G, H>
     (Expr<B>, Expr<C>, Expr<D>, Expr<E>, Expr<F>, Expr<G>, Expr<H>, Expr<I>)
   >
   sum<I extends num>(Expr<I?> Function(Expr<A> a) aggregateBuilder) =>
-      _build(aggregateBuilder, SumExpression._);
+      _build(aggregateBuilder, SumExpression.internal);
 
   /// Add a `AVG` aggregate function to this [Aggregation].
   ///
@@ -13074,7 +13248,7 @@ extension Aggregate1Project7<A, B, C, D, E, F, G, H>
     )
   >
   avg<I extends num>(Expr<I?> Function(Expr<A> a) aggregateBuilder) =>
-      _build(aggregateBuilder, AvgExpression._);
+      _build(aggregateBuilder, AvgExpression.internal);
 
   /// Add a `MIN` aggregate function to this [Aggregation].
   ///
@@ -13090,7 +13264,7 @@ extension Aggregate1Project7<A, B, C, D, E, F, G, H>
     (Expr<B>, Expr<C>, Expr<D>, Expr<E>, Expr<F>, Expr<G>, Expr<H>, Expr<I?>)
   >
   min<I extends Comparable>(Expr<I?> Function(Expr<A> a) aggregateBuilder) =>
-      _build(aggregateBuilder, MinExpression._);
+      _build(aggregateBuilder, MinExpression.internal);
 
   /// Add a `MAX` aggregate function to this [Aggregation].
   ///
@@ -13106,7 +13280,7 @@ extension Aggregate1Project7<A, B, C, D, E, F, G, H>
     (Expr<B>, Expr<C>, Expr<D>, Expr<E>, Expr<F>, Expr<G>, Expr<H>, Expr<I?>)
   >
   max<I extends Comparable>(Expr<I?> Function(Expr<A> a) aggregateBuilder) =>
-      _build(aggregateBuilder, MaxExpression._);
+      _build(aggregateBuilder, MaxExpression.internal);
 
   /// Add a `COUNT(*)` aggregate function to this [Aggregation].
   ///
@@ -13120,7 +13294,7 @@ extension Aggregate1Project7<A, B, C, D, E, F, G, H>
     (Expr<A>,),
     (Expr<B>, Expr<C>, Expr<D>, Expr<E>, Expr<F>, Expr<G>, Expr<H>, Expr<int>)
   >
-  count() => _build((a) => CountAllExpression._(), (a) => a);
+  count() => _build((a) => CountAllExpression.internal(), (a) => a);
 }
 
 /// Extension methods for completing a `GROUP BY`.
@@ -13145,7 +13319,7 @@ extension Group1By2<A, B, C> on Group<(Expr<A>, Expr<B>), (Expr<C>,)> {
     return Query._(
       _from._context,
       agg._projection,
-      (e) => GroupByClause._(
+      (e) => GroupByClause.internal(
         _from._from(_from._expressions.toList()),
         _handle,
         e.take(2).toList(),
@@ -13176,7 +13350,7 @@ extension Aggregate2Project1<A, B, C>
   /// to `NULL` it will coalesced to zero.
   Aggregation<(Expr<A>, Expr<B>), (Expr<C>, Expr<D>)> sum<D extends num>(
     Expr<D?> Function(Expr<A> a, Expr<B> b) aggregateBuilder,
-  ) => _build(aggregateBuilder, SumExpression._);
+  ) => _build(aggregateBuilder, SumExpression.internal);
 
   /// Add a `AVG` aggregate function to this [Aggregation].
   ///
@@ -13193,7 +13367,7 @@ extension Aggregate2Project1<A, B, C>
   /// > `.orElseValue(0)` to force a non-nullable expression.
   Aggregation<(Expr<A>, Expr<B>), (Expr<C>, Expr<double?>)> avg<D extends num>(
     Expr<D?> Function(Expr<A> a, Expr<B> b) aggregateBuilder,
-  ) => _build(aggregateBuilder, AvgExpression._);
+  ) => _build(aggregateBuilder, AvgExpression.internal);
 
   /// Add a `MIN` aggregate function to this [Aggregation].
   ///
@@ -13207,7 +13381,7 @@ extension Aggregate2Project1<A, B, C>
   Aggregation<(Expr<A>, Expr<B>), (Expr<C>, Expr<D?>)>
   min<D extends Comparable>(
     Expr<D?> Function(Expr<A> a, Expr<B> b) aggregateBuilder,
-  ) => _build(aggregateBuilder, MinExpression._);
+  ) => _build(aggregateBuilder, MinExpression.internal);
 
   /// Add a `MAX` aggregate function to this [Aggregation].
   ///
@@ -13221,7 +13395,7 @@ extension Aggregate2Project1<A, B, C>
   Aggregation<(Expr<A>, Expr<B>), (Expr<C>, Expr<D?>)>
   max<D extends Comparable>(
     Expr<D?> Function(Expr<A> a, Expr<B> b) aggregateBuilder,
-  ) => _build(aggregateBuilder, MaxExpression._);
+  ) => _build(aggregateBuilder, MaxExpression.internal);
 
   /// Add a `COUNT(*)` aggregate function to this [Aggregation].
   ///
@@ -13232,7 +13406,7 @@ extension Aggregate2Project1<A, B, C>
   /// This will count the number of rows in the group, including rows consisting
   /// entirely of `NULL` values.
   Aggregation<(Expr<A>, Expr<B>), (Expr<C>, Expr<int>)> count() =>
-      _build((a, b) => CountAllExpression._(), (a) => a);
+      _build((a, b) => CountAllExpression.internal(), (a) => a);
 }
 
 /// Extension methods for completing a `GROUP BY`.
@@ -13258,7 +13432,7 @@ extension Group2By2<A, B, C, D>
     return Query._(
       _from._context,
       agg._projection,
-      (e) => GroupByClause._(
+      (e) => GroupByClause.internal(
         _from._from(_from._expressions.toList()),
         _handle,
         e.take(2).toList(),
@@ -13291,7 +13465,7 @@ extension Aggregate2Project2<A, B, C, D>
   Aggregation<(Expr<A>, Expr<B>), (Expr<C>, Expr<D>, Expr<E>)>
   sum<E extends num>(
     Expr<E?> Function(Expr<A> a, Expr<B> b) aggregateBuilder,
-  ) => _build(aggregateBuilder, SumExpression._);
+  ) => _build(aggregateBuilder, SumExpression.internal);
 
   /// Add a `AVG` aggregate function to this [Aggregation].
   ///
@@ -13309,7 +13483,7 @@ extension Aggregate2Project2<A, B, C, D>
   Aggregation<(Expr<A>, Expr<B>), (Expr<C>, Expr<D>, Expr<double?>)>
   avg<E extends num>(
     Expr<E?> Function(Expr<A> a, Expr<B> b) aggregateBuilder,
-  ) => _build(aggregateBuilder, AvgExpression._);
+  ) => _build(aggregateBuilder, AvgExpression.internal);
 
   /// Add a `MIN` aggregate function to this [Aggregation].
   ///
@@ -13323,7 +13497,7 @@ extension Aggregate2Project2<A, B, C, D>
   Aggregation<(Expr<A>, Expr<B>), (Expr<C>, Expr<D>, Expr<E?>)>
   min<E extends Comparable>(
     Expr<E?> Function(Expr<A> a, Expr<B> b) aggregateBuilder,
-  ) => _build(aggregateBuilder, MinExpression._);
+  ) => _build(aggregateBuilder, MinExpression.internal);
 
   /// Add a `MAX` aggregate function to this [Aggregation].
   ///
@@ -13337,7 +13511,7 @@ extension Aggregate2Project2<A, B, C, D>
   Aggregation<(Expr<A>, Expr<B>), (Expr<C>, Expr<D>, Expr<E?>)>
   max<E extends Comparable>(
     Expr<E?> Function(Expr<A> a, Expr<B> b) aggregateBuilder,
-  ) => _build(aggregateBuilder, MaxExpression._);
+  ) => _build(aggregateBuilder, MaxExpression.internal);
 
   /// Add a `COUNT(*)` aggregate function to this [Aggregation].
   ///
@@ -13348,7 +13522,7 @@ extension Aggregate2Project2<A, B, C, D>
   /// This will count the number of rows in the group, including rows consisting
   /// entirely of `NULL` values.
   Aggregation<(Expr<A>, Expr<B>), (Expr<C>, Expr<D>, Expr<int>)> count() =>
-      _build((a, b) => CountAllExpression._(), (a) => a);
+      _build((a, b) => CountAllExpression.internal(), (a) => a);
 }
 
 /// Extension methods for completing a `GROUP BY`.
@@ -13374,7 +13548,7 @@ extension Group3By2<A, B, C, D, E>
     return Query._(
       _from._context,
       agg._projection,
-      (e) => GroupByClause._(
+      (e) => GroupByClause.internal(
         _from._from(_from._expressions.toList()),
         _handle,
         e.take(2).toList(),
@@ -13409,7 +13583,7 @@ extension Aggregate2Project3<A, B, C, D, E>
   Aggregation<(Expr<A>, Expr<B>), (Expr<C>, Expr<D>, Expr<E>, Expr<F>)>
   sum<F extends num>(
     Expr<F?> Function(Expr<A> a, Expr<B> b) aggregateBuilder,
-  ) => _build(aggregateBuilder, SumExpression._);
+  ) => _build(aggregateBuilder, SumExpression.internal);
 
   /// Add a `AVG` aggregate function to this [Aggregation].
   ///
@@ -13427,7 +13601,7 @@ extension Aggregate2Project3<A, B, C, D, E>
   Aggregation<(Expr<A>, Expr<B>), (Expr<C>, Expr<D>, Expr<E>, Expr<double?>)>
   avg<F extends num>(
     Expr<F?> Function(Expr<A> a, Expr<B> b) aggregateBuilder,
-  ) => _build(aggregateBuilder, AvgExpression._);
+  ) => _build(aggregateBuilder, AvgExpression.internal);
 
   /// Add a `MIN` aggregate function to this [Aggregation].
   ///
@@ -13441,7 +13615,7 @@ extension Aggregate2Project3<A, B, C, D, E>
   Aggregation<(Expr<A>, Expr<B>), (Expr<C>, Expr<D>, Expr<E>, Expr<F?>)>
   min<F extends Comparable>(
     Expr<F?> Function(Expr<A> a, Expr<B> b) aggregateBuilder,
-  ) => _build(aggregateBuilder, MinExpression._);
+  ) => _build(aggregateBuilder, MinExpression.internal);
 
   /// Add a `MAX` aggregate function to this [Aggregation].
   ///
@@ -13455,7 +13629,7 @@ extension Aggregate2Project3<A, B, C, D, E>
   Aggregation<(Expr<A>, Expr<B>), (Expr<C>, Expr<D>, Expr<E>, Expr<F?>)>
   max<F extends Comparable>(
     Expr<F?> Function(Expr<A> a, Expr<B> b) aggregateBuilder,
-  ) => _build(aggregateBuilder, MaxExpression._);
+  ) => _build(aggregateBuilder, MaxExpression.internal);
 
   /// Add a `COUNT(*)` aggregate function to this [Aggregation].
   ///
@@ -13466,7 +13640,7 @@ extension Aggregate2Project3<A, B, C, D, E>
   /// This will count the number of rows in the group, including rows consisting
   /// entirely of `NULL` values.
   Aggregation<(Expr<A>, Expr<B>), (Expr<C>, Expr<D>, Expr<E>, Expr<int>)>
-  count() => _build((a, b) => CountAllExpression._(), (a) => a);
+  count() => _build((a, b) => CountAllExpression.internal(), (a) => a);
 }
 
 /// Extension methods for completing a `GROUP BY`.
@@ -13492,7 +13666,7 @@ extension Group4By2<A, B, C, D, E, F>
     return Query._(
       _from._context,
       agg._projection,
-      (e) => GroupByClause._(
+      (e) => GroupByClause.internal(
         _from._from(_from._expressions.toList()),
         _handle,
         e.take(2).toList(),
@@ -13528,7 +13702,7 @@ extension Aggregate2Project4<A, B, C, D, E, F>
   Aggregation<(Expr<A>, Expr<B>), (Expr<C>, Expr<D>, Expr<E>, Expr<F>, Expr<G>)>
   sum<G extends num>(
     Expr<G?> Function(Expr<A> a, Expr<B> b) aggregateBuilder,
-  ) => _build(aggregateBuilder, SumExpression._);
+  ) => _build(aggregateBuilder, SumExpression.internal);
 
   /// Add a `AVG` aggregate function to this [Aggregation].
   ///
@@ -13549,7 +13723,7 @@ extension Aggregate2Project4<A, B, C, D, E, F>
   >
   avg<G extends num>(
     Expr<G?> Function(Expr<A> a, Expr<B> b) aggregateBuilder,
-  ) => _build(aggregateBuilder, AvgExpression._);
+  ) => _build(aggregateBuilder, AvgExpression.internal);
 
   /// Add a `MIN` aggregate function to this [Aggregation].
   ///
@@ -13566,7 +13740,7 @@ extension Aggregate2Project4<A, B, C, D, E, F>
   >
   min<G extends Comparable>(
     Expr<G?> Function(Expr<A> a, Expr<B> b) aggregateBuilder,
-  ) => _build(aggregateBuilder, MinExpression._);
+  ) => _build(aggregateBuilder, MinExpression.internal);
 
   /// Add a `MAX` aggregate function to this [Aggregation].
   ///
@@ -13583,7 +13757,7 @@ extension Aggregate2Project4<A, B, C, D, E, F>
   >
   max<G extends Comparable>(
     Expr<G?> Function(Expr<A> a, Expr<B> b) aggregateBuilder,
-  ) => _build(aggregateBuilder, MaxExpression._);
+  ) => _build(aggregateBuilder, MaxExpression.internal);
 
   /// Add a `COUNT(*)` aggregate function to this [Aggregation].
   ///
@@ -13597,7 +13771,7 @@ extension Aggregate2Project4<A, B, C, D, E, F>
     (Expr<A>, Expr<B>),
     (Expr<C>, Expr<D>, Expr<E>, Expr<F>, Expr<int>)
   >
-  count() => _build((a, b) => CountAllExpression._(), (a) => a);
+  count() => _build((a, b) => CountAllExpression.internal(), (a) => a);
 }
 
 /// Extension methods for completing a `GROUP BY`.
@@ -13631,7 +13805,7 @@ extension Group5By2<A, B, C, D, E, F, G>
     return Query._(
       _from._context,
       agg._projection,
-      (e) => GroupByClause._(
+      (e) => GroupByClause.internal(
         _from._from(_from._expressions.toList()),
         _handle,
         e.take(2).toList(),
@@ -13678,7 +13852,7 @@ extension Aggregate2Project5<A, B, C, D, E, F, G>
   >
   sum<H extends num>(
     Expr<H?> Function(Expr<A> a, Expr<B> b) aggregateBuilder,
-  ) => _build(aggregateBuilder, SumExpression._);
+  ) => _build(aggregateBuilder, SumExpression.internal);
 
   /// Add a `AVG` aggregate function to this [Aggregation].
   ///
@@ -13699,7 +13873,7 @@ extension Aggregate2Project5<A, B, C, D, E, F, G>
   >
   avg<H extends num>(
     Expr<H?> Function(Expr<A> a, Expr<B> b) aggregateBuilder,
-  ) => _build(aggregateBuilder, AvgExpression._);
+  ) => _build(aggregateBuilder, AvgExpression.internal);
 
   /// Add a `MIN` aggregate function to this [Aggregation].
   ///
@@ -13716,7 +13890,7 @@ extension Aggregate2Project5<A, B, C, D, E, F, G>
   >
   min<H extends Comparable>(
     Expr<H?> Function(Expr<A> a, Expr<B> b) aggregateBuilder,
-  ) => _build(aggregateBuilder, MinExpression._);
+  ) => _build(aggregateBuilder, MinExpression.internal);
 
   /// Add a `MAX` aggregate function to this [Aggregation].
   ///
@@ -13733,7 +13907,7 @@ extension Aggregate2Project5<A, B, C, D, E, F, G>
   >
   max<H extends Comparable>(
     Expr<H?> Function(Expr<A> a, Expr<B> b) aggregateBuilder,
-  ) => _build(aggregateBuilder, MaxExpression._);
+  ) => _build(aggregateBuilder, MaxExpression.internal);
 
   /// Add a `COUNT(*)` aggregate function to this [Aggregation].
   ///
@@ -13747,7 +13921,7 @@ extension Aggregate2Project5<A, B, C, D, E, F, G>
     (Expr<A>, Expr<B>),
     (Expr<C>, Expr<D>, Expr<E>, Expr<F>, Expr<G>, Expr<int>)
   >
-  count() => _build((a, b) => CountAllExpression._(), (a) => a);
+  count() => _build((a, b) => CountAllExpression.internal(), (a) => a);
 }
 
 /// Extension methods for completing a `GROUP BY`.
@@ -13782,7 +13956,7 @@ extension Group6By2<A, B, C, D, E, F, G, H>
     return Query._(
       _from._context,
       agg._projection,
-      (e) => GroupByClause._(
+      (e) => GroupByClause.internal(
         _from._from(_from._expressions.toList()),
         _handle,
         e.take(2).toList(),
@@ -13830,7 +14004,7 @@ extension Aggregate2Project6<A, B, C, D, E, F, G, H>
   >
   sum<I extends num>(
     Expr<I?> Function(Expr<A> a, Expr<B> b) aggregateBuilder,
-  ) => _build(aggregateBuilder, SumExpression._);
+  ) => _build(aggregateBuilder, SumExpression.internal);
 
   /// Add a `AVG` aggregate function to this [Aggregation].
   ///
@@ -13851,7 +14025,7 @@ extension Aggregate2Project6<A, B, C, D, E, F, G, H>
   >
   avg<I extends num>(
     Expr<I?> Function(Expr<A> a, Expr<B> b) aggregateBuilder,
-  ) => _build(aggregateBuilder, AvgExpression._);
+  ) => _build(aggregateBuilder, AvgExpression.internal);
 
   /// Add a `MIN` aggregate function to this [Aggregation].
   ///
@@ -13868,7 +14042,7 @@ extension Aggregate2Project6<A, B, C, D, E, F, G, H>
   >
   min<I extends Comparable>(
     Expr<I?> Function(Expr<A> a, Expr<B> b) aggregateBuilder,
-  ) => _build(aggregateBuilder, MinExpression._);
+  ) => _build(aggregateBuilder, MinExpression.internal);
 
   /// Add a `MAX` aggregate function to this [Aggregation].
   ///
@@ -13885,7 +14059,7 @@ extension Aggregate2Project6<A, B, C, D, E, F, G, H>
   >
   max<I extends Comparable>(
     Expr<I?> Function(Expr<A> a, Expr<B> b) aggregateBuilder,
-  ) => _build(aggregateBuilder, MaxExpression._);
+  ) => _build(aggregateBuilder, MaxExpression.internal);
 
   /// Add a `COUNT(*)` aggregate function to this [Aggregation].
   ///
@@ -13899,7 +14073,7 @@ extension Aggregate2Project6<A, B, C, D, E, F, G, H>
     (Expr<A>, Expr<B>),
     (Expr<C>, Expr<D>, Expr<E>, Expr<F>, Expr<G>, Expr<H>, Expr<int>)
   >
-  count() => _build((a, b) => CountAllExpression._(), (a) => a);
+  count() => _build((a, b) => CountAllExpression.internal(), (a) => a);
 }
 
 /// Extension methods for completing a `GROUP BY`.
@@ -13925,7 +14099,7 @@ extension Group1By3<A, B, C, D>
     return Query._(
       _from._context,
       agg._projection,
-      (e) => GroupByClause._(
+      (e) => GroupByClause.internal(
         _from._from(_from._expressions.toList()),
         _handle,
         e.take(3).toList(),
@@ -13957,7 +14131,7 @@ extension Aggregate3Project1<A, B, C, D>
   Aggregation<(Expr<A>, Expr<B>, Expr<C>), (Expr<D>, Expr<E>)>
   sum<E extends num>(
     Expr<E?> Function(Expr<A> a, Expr<B> b, Expr<C> c) aggregateBuilder,
-  ) => _build(aggregateBuilder, SumExpression._);
+  ) => _build(aggregateBuilder, SumExpression.internal);
 
   /// Add a `AVG` aggregate function to this [Aggregation].
   ///
@@ -13975,7 +14149,7 @@ extension Aggregate3Project1<A, B, C, D>
   Aggregation<(Expr<A>, Expr<B>, Expr<C>), (Expr<D>, Expr<double?>)>
   avg<E extends num>(
     Expr<E?> Function(Expr<A> a, Expr<B> b, Expr<C> c) aggregateBuilder,
-  ) => _build(aggregateBuilder, AvgExpression._);
+  ) => _build(aggregateBuilder, AvgExpression.internal);
 
   /// Add a `MIN` aggregate function to this [Aggregation].
   ///
@@ -13989,7 +14163,7 @@ extension Aggregate3Project1<A, B, C, D>
   Aggregation<(Expr<A>, Expr<B>, Expr<C>), (Expr<D>, Expr<E?>)>
   min<E extends Comparable>(
     Expr<E?> Function(Expr<A> a, Expr<B> b, Expr<C> c) aggregateBuilder,
-  ) => _build(aggregateBuilder, MinExpression._);
+  ) => _build(aggregateBuilder, MinExpression.internal);
 
   /// Add a `MAX` aggregate function to this [Aggregation].
   ///
@@ -14003,7 +14177,7 @@ extension Aggregate3Project1<A, B, C, D>
   Aggregation<(Expr<A>, Expr<B>, Expr<C>), (Expr<D>, Expr<E?>)>
   max<E extends Comparable>(
     Expr<E?> Function(Expr<A> a, Expr<B> b, Expr<C> c) aggregateBuilder,
-  ) => _build(aggregateBuilder, MaxExpression._);
+  ) => _build(aggregateBuilder, MaxExpression.internal);
 
   /// Add a `COUNT(*)` aggregate function to this [Aggregation].
   ///
@@ -14014,7 +14188,7 @@ extension Aggregate3Project1<A, B, C, D>
   /// This will count the number of rows in the group, including rows consisting
   /// entirely of `NULL` values.
   Aggregation<(Expr<A>, Expr<B>, Expr<C>), (Expr<D>, Expr<int>)> count() =>
-      _build((a, b, c) => CountAllExpression._(), (a) => a);
+      _build((a, b, c) => CountAllExpression.internal(), (a) => a);
 }
 
 /// Extension methods for completing a `GROUP BY`.
@@ -14040,7 +14214,7 @@ extension Group2By3<A, B, C, D, E>
     return Query._(
       _from._context,
       agg._projection,
-      (e) => GroupByClause._(
+      (e) => GroupByClause.internal(
         _from._from(_from._expressions.toList()),
         _handle,
         e.take(3).toList(),
@@ -14074,7 +14248,7 @@ extension Aggregate3Project2<A, B, C, D, E>
   Aggregation<(Expr<A>, Expr<B>, Expr<C>), (Expr<D>, Expr<E>, Expr<F>)>
   sum<F extends num>(
     Expr<F?> Function(Expr<A> a, Expr<B> b, Expr<C> c) aggregateBuilder,
-  ) => _build(aggregateBuilder, SumExpression._);
+  ) => _build(aggregateBuilder, SumExpression.internal);
 
   /// Add a `AVG` aggregate function to this [Aggregation].
   ///
@@ -14092,7 +14266,7 @@ extension Aggregate3Project2<A, B, C, D, E>
   Aggregation<(Expr<A>, Expr<B>, Expr<C>), (Expr<D>, Expr<E>, Expr<double?>)>
   avg<F extends num>(
     Expr<F?> Function(Expr<A> a, Expr<B> b, Expr<C> c) aggregateBuilder,
-  ) => _build(aggregateBuilder, AvgExpression._);
+  ) => _build(aggregateBuilder, AvgExpression.internal);
 
   /// Add a `MIN` aggregate function to this [Aggregation].
   ///
@@ -14106,7 +14280,7 @@ extension Aggregate3Project2<A, B, C, D, E>
   Aggregation<(Expr<A>, Expr<B>, Expr<C>), (Expr<D>, Expr<E>, Expr<F?>)>
   min<F extends Comparable>(
     Expr<F?> Function(Expr<A> a, Expr<B> b, Expr<C> c) aggregateBuilder,
-  ) => _build(aggregateBuilder, MinExpression._);
+  ) => _build(aggregateBuilder, MinExpression.internal);
 
   /// Add a `MAX` aggregate function to this [Aggregation].
   ///
@@ -14120,7 +14294,7 @@ extension Aggregate3Project2<A, B, C, D, E>
   Aggregation<(Expr<A>, Expr<B>, Expr<C>), (Expr<D>, Expr<E>, Expr<F?>)>
   max<F extends Comparable>(
     Expr<F?> Function(Expr<A> a, Expr<B> b, Expr<C> c) aggregateBuilder,
-  ) => _build(aggregateBuilder, MaxExpression._);
+  ) => _build(aggregateBuilder, MaxExpression.internal);
 
   /// Add a `COUNT(*)` aggregate function to this [Aggregation].
   ///
@@ -14131,7 +14305,7 @@ extension Aggregate3Project2<A, B, C, D, E>
   /// This will count the number of rows in the group, including rows consisting
   /// entirely of `NULL` values.
   Aggregation<(Expr<A>, Expr<B>, Expr<C>), (Expr<D>, Expr<E>, Expr<int>)>
-  count() => _build((a, b, c) => CountAllExpression._(), (a) => a);
+  count() => _build((a, b, c) => CountAllExpression.internal(), (a) => a);
 }
 
 /// Extension methods for completing a `GROUP BY`.
@@ -14157,7 +14331,7 @@ extension Group3By3<A, B, C, D, E, F>
     return Query._(
       _from._context,
       agg._projection,
-      (e) => GroupByClause._(
+      (e) => GroupByClause.internal(
         _from._from(_from._expressions.toList()),
         _handle,
         e.take(3).toList(),
@@ -14192,7 +14366,7 @@ extension Aggregate3Project3<A, B, C, D, E, F>
   Aggregation<(Expr<A>, Expr<B>, Expr<C>), (Expr<D>, Expr<E>, Expr<F>, Expr<G>)>
   sum<G extends num>(
     Expr<G?> Function(Expr<A> a, Expr<B> b, Expr<C> c) aggregateBuilder,
-  ) => _build(aggregateBuilder, SumExpression._);
+  ) => _build(aggregateBuilder, SumExpression.internal);
 
   /// Add a `AVG` aggregate function to this [Aggregation].
   ///
@@ -14213,7 +14387,7 @@ extension Aggregate3Project3<A, B, C, D, E, F>
   >
   avg<G extends num>(
     Expr<G?> Function(Expr<A> a, Expr<B> b, Expr<C> c) aggregateBuilder,
-  ) => _build(aggregateBuilder, AvgExpression._);
+  ) => _build(aggregateBuilder, AvgExpression.internal);
 
   /// Add a `MIN` aggregate function to this [Aggregation].
   ///
@@ -14230,7 +14404,7 @@ extension Aggregate3Project3<A, B, C, D, E, F>
   >
   min<G extends Comparable>(
     Expr<G?> Function(Expr<A> a, Expr<B> b, Expr<C> c) aggregateBuilder,
-  ) => _build(aggregateBuilder, MinExpression._);
+  ) => _build(aggregateBuilder, MinExpression.internal);
 
   /// Add a `MAX` aggregate function to this [Aggregation].
   ///
@@ -14247,7 +14421,7 @@ extension Aggregate3Project3<A, B, C, D, E, F>
   >
   max<G extends Comparable>(
     Expr<G?> Function(Expr<A> a, Expr<B> b, Expr<C> c) aggregateBuilder,
-  ) => _build(aggregateBuilder, MaxExpression._);
+  ) => _build(aggregateBuilder, MaxExpression.internal);
 
   /// Add a `COUNT(*)` aggregate function to this [Aggregation].
   ///
@@ -14261,7 +14435,7 @@ extension Aggregate3Project3<A, B, C, D, E, F>
     (Expr<A>, Expr<B>, Expr<C>),
     (Expr<D>, Expr<E>, Expr<F>, Expr<int>)
   >
-  count() => _build((a, b, c) => CountAllExpression._(), (a) => a);
+  count() => _build((a, b, c) => CountAllExpression.internal(), (a) => a);
 }
 
 /// Extension methods for completing a `GROUP BY`.
@@ -14295,7 +14469,7 @@ extension Group4By3<A, B, C, D, E, F, G>
     return Query._(
       _from._context,
       agg._projection,
-      (e) => GroupByClause._(
+      (e) => GroupByClause.internal(
         _from._from(_from._expressions.toList()),
         _handle,
         e.take(3).toList(),
@@ -14341,7 +14515,7 @@ extension Aggregate3Project4<A, B, C, D, E, F, G>
   >
   sum<H extends num>(
     Expr<H?> Function(Expr<A> a, Expr<B> b, Expr<C> c) aggregateBuilder,
-  ) => _build(aggregateBuilder, SumExpression._);
+  ) => _build(aggregateBuilder, SumExpression.internal);
 
   /// Add a `AVG` aggregate function to this [Aggregation].
   ///
@@ -14362,7 +14536,7 @@ extension Aggregate3Project4<A, B, C, D, E, F, G>
   >
   avg<H extends num>(
     Expr<H?> Function(Expr<A> a, Expr<B> b, Expr<C> c) aggregateBuilder,
-  ) => _build(aggregateBuilder, AvgExpression._);
+  ) => _build(aggregateBuilder, AvgExpression.internal);
 
   /// Add a `MIN` aggregate function to this [Aggregation].
   ///
@@ -14379,7 +14553,7 @@ extension Aggregate3Project4<A, B, C, D, E, F, G>
   >
   min<H extends Comparable>(
     Expr<H?> Function(Expr<A> a, Expr<B> b, Expr<C> c) aggregateBuilder,
-  ) => _build(aggregateBuilder, MinExpression._);
+  ) => _build(aggregateBuilder, MinExpression.internal);
 
   /// Add a `MAX` aggregate function to this [Aggregation].
   ///
@@ -14396,7 +14570,7 @@ extension Aggregate3Project4<A, B, C, D, E, F, G>
   >
   max<H extends Comparable>(
     Expr<H?> Function(Expr<A> a, Expr<B> b, Expr<C> c) aggregateBuilder,
-  ) => _build(aggregateBuilder, MaxExpression._);
+  ) => _build(aggregateBuilder, MaxExpression.internal);
 
   /// Add a `COUNT(*)` aggregate function to this [Aggregation].
   ///
@@ -14410,7 +14584,7 @@ extension Aggregate3Project4<A, B, C, D, E, F, G>
     (Expr<A>, Expr<B>, Expr<C>),
     (Expr<D>, Expr<E>, Expr<F>, Expr<G>, Expr<int>)
   >
-  count() => _build((a, b, c) => CountAllExpression._(), (a) => a);
+  count() => _build((a, b, c) => CountAllExpression.internal(), (a) => a);
 }
 
 /// Extension methods for completing a `GROUP BY`.
@@ -14444,7 +14618,7 @@ extension Group5By3<A, B, C, D, E, F, G, H>
     return Query._(
       _from._context,
       agg._projection,
-      (e) => GroupByClause._(
+      (e) => GroupByClause.internal(
         _from._from(_from._expressions.toList()),
         _handle,
         e.take(3).toList(),
@@ -14491,7 +14665,7 @@ extension Aggregate3Project5<A, B, C, D, E, F, G, H>
   >
   sum<I extends num>(
     Expr<I?> Function(Expr<A> a, Expr<B> b, Expr<C> c) aggregateBuilder,
-  ) => _build(aggregateBuilder, SumExpression._);
+  ) => _build(aggregateBuilder, SumExpression.internal);
 
   /// Add a `AVG` aggregate function to this [Aggregation].
   ///
@@ -14512,7 +14686,7 @@ extension Aggregate3Project5<A, B, C, D, E, F, G, H>
   >
   avg<I extends num>(
     Expr<I?> Function(Expr<A> a, Expr<B> b, Expr<C> c) aggregateBuilder,
-  ) => _build(aggregateBuilder, AvgExpression._);
+  ) => _build(aggregateBuilder, AvgExpression.internal);
 
   /// Add a `MIN` aggregate function to this [Aggregation].
   ///
@@ -14529,7 +14703,7 @@ extension Aggregate3Project5<A, B, C, D, E, F, G, H>
   >
   min<I extends Comparable>(
     Expr<I?> Function(Expr<A> a, Expr<B> b, Expr<C> c) aggregateBuilder,
-  ) => _build(aggregateBuilder, MinExpression._);
+  ) => _build(aggregateBuilder, MinExpression.internal);
 
   /// Add a `MAX` aggregate function to this [Aggregation].
   ///
@@ -14546,7 +14720,7 @@ extension Aggregate3Project5<A, B, C, D, E, F, G, H>
   >
   max<I extends Comparable>(
     Expr<I?> Function(Expr<A> a, Expr<B> b, Expr<C> c) aggregateBuilder,
-  ) => _build(aggregateBuilder, MaxExpression._);
+  ) => _build(aggregateBuilder, MaxExpression.internal);
 
   /// Add a `COUNT(*)` aggregate function to this [Aggregation].
   ///
@@ -14560,7 +14734,7 @@ extension Aggregate3Project5<A, B, C, D, E, F, G, H>
     (Expr<A>, Expr<B>, Expr<C>),
     (Expr<D>, Expr<E>, Expr<F>, Expr<G>, Expr<H>, Expr<int>)
   >
-  count() => _build((a, b, c) => CountAllExpression._(), (a) => a);
+  count() => _build((a, b, c) => CountAllExpression.internal(), (a) => a);
 }
 
 /// Extension methods for completing a `GROUP BY`.
@@ -14586,7 +14760,7 @@ extension Group1By4<A, B, C, D, E>
     return Query._(
       _from._context,
       agg._projection,
-      (e) => GroupByClause._(
+      (e) => GroupByClause.internal(
         _from._from(_from._expressions.toList()),
         _handle,
         e.take(4).toList(),
@@ -14623,7 +14797,7 @@ extension Aggregate4Project1<A, B, C, D, E>
   sum<F extends num>(
     Expr<F?> Function(Expr<A> a, Expr<B> b, Expr<C> c, Expr<D> d)
     aggregateBuilder,
-  ) => _build(aggregateBuilder, SumExpression._);
+  ) => _build(aggregateBuilder, SumExpression.internal);
 
   /// Add a `AVG` aggregate function to this [Aggregation].
   ///
@@ -14642,7 +14816,7 @@ extension Aggregate4Project1<A, B, C, D, E>
   avg<F extends num>(
     Expr<F?> Function(Expr<A> a, Expr<B> b, Expr<C> c, Expr<D> d)
     aggregateBuilder,
-  ) => _build(aggregateBuilder, AvgExpression._);
+  ) => _build(aggregateBuilder, AvgExpression.internal);
 
   /// Add a `MIN` aggregate function to this [Aggregation].
   ///
@@ -14657,7 +14831,7 @@ extension Aggregate4Project1<A, B, C, D, E>
   min<F extends Comparable>(
     Expr<F?> Function(Expr<A> a, Expr<B> b, Expr<C> c, Expr<D> d)
     aggregateBuilder,
-  ) => _build(aggregateBuilder, MinExpression._);
+  ) => _build(aggregateBuilder, MinExpression.internal);
 
   /// Add a `MAX` aggregate function to this [Aggregation].
   ///
@@ -14672,7 +14846,7 @@ extension Aggregate4Project1<A, B, C, D, E>
   max<F extends Comparable>(
     Expr<F?> Function(Expr<A> a, Expr<B> b, Expr<C> c, Expr<D> d)
     aggregateBuilder,
-  ) => _build(aggregateBuilder, MaxExpression._);
+  ) => _build(aggregateBuilder, MaxExpression.internal);
 
   /// Add a `COUNT(*)` aggregate function to this [Aggregation].
   ///
@@ -14683,7 +14857,7 @@ extension Aggregate4Project1<A, B, C, D, E>
   /// This will count the number of rows in the group, including rows consisting
   /// entirely of `NULL` values.
   Aggregation<(Expr<A>, Expr<B>, Expr<C>, Expr<D>), (Expr<E>, Expr<int>)>
-  count() => _build((a, b, c, d) => CountAllExpression._(), (a) => a);
+  count() => _build((a, b, c, d) => CountAllExpression.internal(), (a) => a);
 }
 
 /// Extension methods for completing a `GROUP BY`.
@@ -14709,7 +14883,7 @@ extension Group2By4<A, B, C, D, E, F>
     return Query._(
       _from._context,
       agg._projection,
-      (e) => GroupByClause._(
+      (e) => GroupByClause.internal(
         _from._from(_from._expressions.toList()),
         _handle,
         e.take(4).toList(),
@@ -14747,7 +14921,7 @@ extension Aggregate4Project2<A, B, C, D, E, F>
   sum<G extends num>(
     Expr<G?> Function(Expr<A> a, Expr<B> b, Expr<C> c, Expr<D> d)
     aggregateBuilder,
-  ) => _build(aggregateBuilder, SumExpression._);
+  ) => _build(aggregateBuilder, SumExpression.internal);
 
   /// Add a `AVG` aggregate function to this [Aggregation].
   ///
@@ -14769,7 +14943,7 @@ extension Aggregate4Project2<A, B, C, D, E, F>
   avg<G extends num>(
     Expr<G?> Function(Expr<A> a, Expr<B> b, Expr<C> c, Expr<D> d)
     aggregateBuilder,
-  ) => _build(aggregateBuilder, AvgExpression._);
+  ) => _build(aggregateBuilder, AvgExpression.internal);
 
   /// Add a `MIN` aggregate function to this [Aggregation].
   ///
@@ -14787,7 +14961,7 @@ extension Aggregate4Project2<A, B, C, D, E, F>
   min<G extends Comparable>(
     Expr<G?> Function(Expr<A> a, Expr<B> b, Expr<C> c, Expr<D> d)
     aggregateBuilder,
-  ) => _build(aggregateBuilder, MinExpression._);
+  ) => _build(aggregateBuilder, MinExpression.internal);
 
   /// Add a `MAX` aggregate function to this [Aggregation].
   ///
@@ -14805,7 +14979,7 @@ extension Aggregate4Project2<A, B, C, D, E, F>
   max<G extends Comparable>(
     Expr<G?> Function(Expr<A> a, Expr<B> b, Expr<C> c, Expr<D> d)
     aggregateBuilder,
-  ) => _build(aggregateBuilder, MaxExpression._);
+  ) => _build(aggregateBuilder, MaxExpression.internal);
 
   /// Add a `COUNT(*)` aggregate function to this [Aggregation].
   ///
@@ -14819,7 +14993,7 @@ extension Aggregate4Project2<A, B, C, D, E, F>
     (Expr<A>, Expr<B>, Expr<C>, Expr<D>),
     (Expr<E>, Expr<F>, Expr<int>)
   >
-  count() => _build((a, b, c, d) => CountAllExpression._(), (a) => a);
+  count() => _build((a, b, c, d) => CountAllExpression.internal(), (a) => a);
 }
 
 /// Extension methods for completing a `GROUP BY`.
@@ -14853,7 +15027,7 @@ extension Group3By4<A, B, C, D, E, F, G>
     return Query._(
       _from._context,
       agg._projection,
-      (e) => GroupByClause._(
+      (e) => GroupByClause.internal(
         _from._from(_from._expressions.toList()),
         _handle,
         e.take(4).toList(),
@@ -14902,7 +15076,7 @@ extension Aggregate4Project3<A, B, C, D, E, F, G>
   sum<H extends num>(
     Expr<H?> Function(Expr<A> a, Expr<B> b, Expr<C> c, Expr<D> d)
     aggregateBuilder,
-  ) => _build(aggregateBuilder, SumExpression._);
+  ) => _build(aggregateBuilder, SumExpression.internal);
 
   /// Add a `AVG` aggregate function to this [Aggregation].
   ///
@@ -14924,7 +15098,7 @@ extension Aggregate4Project3<A, B, C, D, E, F, G>
   avg<H extends num>(
     Expr<H?> Function(Expr<A> a, Expr<B> b, Expr<C> c, Expr<D> d)
     aggregateBuilder,
-  ) => _build(aggregateBuilder, AvgExpression._);
+  ) => _build(aggregateBuilder, AvgExpression.internal);
 
   /// Add a `MIN` aggregate function to this [Aggregation].
   ///
@@ -14942,7 +15116,7 @@ extension Aggregate4Project3<A, B, C, D, E, F, G>
   min<H extends Comparable>(
     Expr<H?> Function(Expr<A> a, Expr<B> b, Expr<C> c, Expr<D> d)
     aggregateBuilder,
-  ) => _build(aggregateBuilder, MinExpression._);
+  ) => _build(aggregateBuilder, MinExpression.internal);
 
   /// Add a `MAX` aggregate function to this [Aggregation].
   ///
@@ -14960,7 +15134,7 @@ extension Aggregate4Project3<A, B, C, D, E, F, G>
   max<H extends Comparable>(
     Expr<H?> Function(Expr<A> a, Expr<B> b, Expr<C> c, Expr<D> d)
     aggregateBuilder,
-  ) => _build(aggregateBuilder, MaxExpression._);
+  ) => _build(aggregateBuilder, MaxExpression.internal);
 
   /// Add a `COUNT(*)` aggregate function to this [Aggregation].
   ///
@@ -14974,7 +15148,7 @@ extension Aggregate4Project3<A, B, C, D, E, F, G>
     (Expr<A>, Expr<B>, Expr<C>, Expr<D>),
     (Expr<E>, Expr<F>, Expr<G>, Expr<int>)
   >
-  count() => _build((a, b, c, d) => CountAllExpression._(), (a) => a);
+  count() => _build((a, b, c, d) => CountAllExpression.internal(), (a) => a);
 }
 
 /// Extension methods for completing a `GROUP BY`.
@@ -15008,7 +15182,7 @@ extension Group4By4<A, B, C, D, E, F, G, H>
     return Query._(
       _from._context,
       agg._projection,
-      (e) => GroupByClause._(
+      (e) => GroupByClause.internal(
         _from._from(_from._expressions.toList()),
         _handle,
         e.take(4).toList(),
@@ -15058,7 +15232,7 @@ extension Aggregate4Project4<A, B, C, D, E, F, G, H>
   sum<I extends num>(
     Expr<I?> Function(Expr<A> a, Expr<B> b, Expr<C> c, Expr<D> d)
     aggregateBuilder,
-  ) => _build(aggregateBuilder, SumExpression._);
+  ) => _build(aggregateBuilder, SumExpression.internal);
 
   /// Add a `AVG` aggregate function to this [Aggregation].
   ///
@@ -15080,7 +15254,7 @@ extension Aggregate4Project4<A, B, C, D, E, F, G, H>
   avg<I extends num>(
     Expr<I?> Function(Expr<A> a, Expr<B> b, Expr<C> c, Expr<D> d)
     aggregateBuilder,
-  ) => _build(aggregateBuilder, AvgExpression._);
+  ) => _build(aggregateBuilder, AvgExpression.internal);
 
   /// Add a `MIN` aggregate function to this [Aggregation].
   ///
@@ -15098,7 +15272,7 @@ extension Aggregate4Project4<A, B, C, D, E, F, G, H>
   min<I extends Comparable>(
     Expr<I?> Function(Expr<A> a, Expr<B> b, Expr<C> c, Expr<D> d)
     aggregateBuilder,
-  ) => _build(aggregateBuilder, MinExpression._);
+  ) => _build(aggregateBuilder, MinExpression.internal);
 
   /// Add a `MAX` aggregate function to this [Aggregation].
   ///
@@ -15116,7 +15290,7 @@ extension Aggregate4Project4<A, B, C, D, E, F, G, H>
   max<I extends Comparable>(
     Expr<I?> Function(Expr<A> a, Expr<B> b, Expr<C> c, Expr<D> d)
     aggregateBuilder,
-  ) => _build(aggregateBuilder, MaxExpression._);
+  ) => _build(aggregateBuilder, MaxExpression.internal);
 
   /// Add a `COUNT(*)` aggregate function to this [Aggregation].
   ///
@@ -15130,7 +15304,7 @@ extension Aggregate4Project4<A, B, C, D, E, F, G, H>
     (Expr<A>, Expr<B>, Expr<C>, Expr<D>),
     (Expr<E>, Expr<F>, Expr<G>, Expr<H>, Expr<int>)
   >
-  count() => _build((a, b, c, d) => CountAllExpression._(), (a) => a);
+  count() => _build((a, b, c, d) => CountAllExpression.internal(), (a) => a);
 }
 
 /// Extension methods for completing a `GROUP BY`.
@@ -15157,7 +15331,7 @@ extension Group1By5<A, B, C, D, E, F>
     return Query._(
       _from._context,
       agg._projection,
-      (e) => GroupByClause._(
+      (e) => GroupByClause.internal(
         _from._from(_from._expressions.toList()),
         _handle,
         e.take(5).toList(),
@@ -15200,7 +15374,7 @@ extension Aggregate5Project1<A, B, C, D, E, F>
   sum<G extends num>(
     Expr<G?> Function(Expr<A> a, Expr<B> b, Expr<C> c, Expr<D> d, Expr<E> e)
     aggregateBuilder,
-  ) => _build(aggregateBuilder, SumExpression._);
+  ) => _build(aggregateBuilder, SumExpression.internal);
 
   /// Add a `AVG` aggregate function to this [Aggregation].
   ///
@@ -15222,7 +15396,7 @@ extension Aggregate5Project1<A, B, C, D, E, F>
   avg<G extends num>(
     Expr<G?> Function(Expr<A> a, Expr<B> b, Expr<C> c, Expr<D> d, Expr<E> e)
     aggregateBuilder,
-  ) => _build(aggregateBuilder, AvgExpression._);
+  ) => _build(aggregateBuilder, AvgExpression.internal);
 
   /// Add a `MIN` aggregate function to this [Aggregation].
   ///
@@ -15240,7 +15414,7 @@ extension Aggregate5Project1<A, B, C, D, E, F>
   min<G extends Comparable>(
     Expr<G?> Function(Expr<A> a, Expr<B> b, Expr<C> c, Expr<D> d, Expr<E> e)
     aggregateBuilder,
-  ) => _build(aggregateBuilder, MinExpression._);
+  ) => _build(aggregateBuilder, MinExpression.internal);
 
   /// Add a `MAX` aggregate function to this [Aggregation].
   ///
@@ -15258,7 +15432,7 @@ extension Aggregate5Project1<A, B, C, D, E, F>
   max<G extends Comparable>(
     Expr<G?> Function(Expr<A> a, Expr<B> b, Expr<C> c, Expr<D> d, Expr<E> e)
     aggregateBuilder,
-  ) => _build(aggregateBuilder, MaxExpression._);
+  ) => _build(aggregateBuilder, MaxExpression.internal);
 
   /// Add a `COUNT(*)` aggregate function to this [Aggregation].
   ///
@@ -15272,7 +15446,7 @@ extension Aggregate5Project1<A, B, C, D, E, F>
     (Expr<A>, Expr<B>, Expr<C>, Expr<D>, Expr<E>),
     (Expr<F>, Expr<int>)
   >
-  count() => _build((a, b, c, d, e) => CountAllExpression._(), (a) => a);
+  count() => _build((a, b, c, d, e) => CountAllExpression.internal(), (a) => a);
 }
 
 /// Extension methods for completing a `GROUP BY`.
@@ -15306,7 +15480,7 @@ extension Group2By5<A, B, C, D, E, F, G>
     return Query._(
       _from._context,
       agg._projection,
-      (e) => GroupByClause._(
+      (e) => GroupByClause.internal(
         _from._from(_from._expressions.toList()),
         _handle,
         e.take(5).toList(),
@@ -15360,7 +15534,7 @@ extension Aggregate5Project2<A, B, C, D, E, F, G>
   sum<H extends num>(
     Expr<H?> Function(Expr<A> a, Expr<B> b, Expr<C> c, Expr<D> d, Expr<E> e)
     aggregateBuilder,
-  ) => _build(aggregateBuilder, SumExpression._);
+  ) => _build(aggregateBuilder, SumExpression.internal);
 
   /// Add a `AVG` aggregate function to this [Aggregation].
   ///
@@ -15382,7 +15556,7 @@ extension Aggregate5Project2<A, B, C, D, E, F, G>
   avg<H extends num>(
     Expr<H?> Function(Expr<A> a, Expr<B> b, Expr<C> c, Expr<D> d, Expr<E> e)
     aggregateBuilder,
-  ) => _build(aggregateBuilder, AvgExpression._);
+  ) => _build(aggregateBuilder, AvgExpression.internal);
 
   /// Add a `MIN` aggregate function to this [Aggregation].
   ///
@@ -15400,7 +15574,7 @@ extension Aggregate5Project2<A, B, C, D, E, F, G>
   min<H extends Comparable>(
     Expr<H?> Function(Expr<A> a, Expr<B> b, Expr<C> c, Expr<D> d, Expr<E> e)
     aggregateBuilder,
-  ) => _build(aggregateBuilder, MinExpression._);
+  ) => _build(aggregateBuilder, MinExpression.internal);
 
   /// Add a `MAX` aggregate function to this [Aggregation].
   ///
@@ -15418,7 +15592,7 @@ extension Aggregate5Project2<A, B, C, D, E, F, G>
   max<H extends Comparable>(
     Expr<H?> Function(Expr<A> a, Expr<B> b, Expr<C> c, Expr<D> d, Expr<E> e)
     aggregateBuilder,
-  ) => _build(aggregateBuilder, MaxExpression._);
+  ) => _build(aggregateBuilder, MaxExpression.internal);
 
   /// Add a `COUNT(*)` aggregate function to this [Aggregation].
   ///
@@ -15432,7 +15606,7 @@ extension Aggregate5Project2<A, B, C, D, E, F, G>
     (Expr<A>, Expr<B>, Expr<C>, Expr<D>, Expr<E>),
     (Expr<F>, Expr<G>, Expr<int>)
   >
-  count() => _build((a, b, c, d, e) => CountAllExpression._(), (a) => a);
+  count() => _build((a, b, c, d, e) => CountAllExpression.internal(), (a) => a);
 }
 
 /// Extension methods for completing a `GROUP BY`.
@@ -15466,7 +15640,7 @@ extension Group3By5<A, B, C, D, E, F, G, H>
     return Query._(
       _from._context,
       agg._projection,
-      (e) => GroupByClause._(
+      (e) => GroupByClause.internal(
         _from._from(_from._expressions.toList()),
         _handle,
         e.take(5).toList(),
@@ -15521,7 +15695,7 @@ extension Aggregate5Project3<A, B, C, D, E, F, G, H>
   sum<I extends num>(
     Expr<I?> Function(Expr<A> a, Expr<B> b, Expr<C> c, Expr<D> d, Expr<E> e)
     aggregateBuilder,
-  ) => _build(aggregateBuilder, SumExpression._);
+  ) => _build(aggregateBuilder, SumExpression.internal);
 
   /// Add a `AVG` aggregate function to this [Aggregation].
   ///
@@ -15543,7 +15717,7 @@ extension Aggregate5Project3<A, B, C, D, E, F, G, H>
   avg<I extends num>(
     Expr<I?> Function(Expr<A> a, Expr<B> b, Expr<C> c, Expr<D> d, Expr<E> e)
     aggregateBuilder,
-  ) => _build(aggregateBuilder, AvgExpression._);
+  ) => _build(aggregateBuilder, AvgExpression.internal);
 
   /// Add a `MIN` aggregate function to this [Aggregation].
   ///
@@ -15561,7 +15735,7 @@ extension Aggregate5Project3<A, B, C, D, E, F, G, H>
   min<I extends Comparable>(
     Expr<I?> Function(Expr<A> a, Expr<B> b, Expr<C> c, Expr<D> d, Expr<E> e)
     aggregateBuilder,
-  ) => _build(aggregateBuilder, MinExpression._);
+  ) => _build(aggregateBuilder, MinExpression.internal);
 
   /// Add a `MAX` aggregate function to this [Aggregation].
   ///
@@ -15579,7 +15753,7 @@ extension Aggregate5Project3<A, B, C, D, E, F, G, H>
   max<I extends Comparable>(
     Expr<I?> Function(Expr<A> a, Expr<B> b, Expr<C> c, Expr<D> d, Expr<E> e)
     aggregateBuilder,
-  ) => _build(aggregateBuilder, MaxExpression._);
+  ) => _build(aggregateBuilder, MaxExpression.internal);
 
   /// Add a `COUNT(*)` aggregate function to this [Aggregation].
   ///
@@ -15593,7 +15767,7 @@ extension Aggregate5Project3<A, B, C, D, E, F, G, H>
     (Expr<A>, Expr<B>, Expr<C>, Expr<D>, Expr<E>),
     (Expr<F>, Expr<G>, Expr<H>, Expr<int>)
   >
-  count() => _build((a, b, c, d, e) => CountAllExpression._(), (a) => a);
+  count() => _build((a, b, c, d, e) => CountAllExpression.internal(), (a) => a);
 }
 
 /// Extension methods for completing a `GROUP BY`.
@@ -15627,7 +15801,7 @@ extension Group1By6<A, B, C, D, E, F, G>
     return Query._(
       _from._context,
       agg._projection,
-      (e) => GroupByClause._(
+      (e) => GroupByClause.internal(
         _from._from(_from._expressions.toList()),
         _handle,
         e.take(6).toList(),
@@ -15695,7 +15869,7 @@ extension Aggregate6Project1<A, B, C, D, E, F, G>
       Expr<F> f,
     )
     aggregateBuilder,
-  ) => _build(aggregateBuilder, SumExpression._);
+  ) => _build(aggregateBuilder, SumExpression.internal);
 
   /// Add a `AVG` aggregate function to this [Aggregation].
   ///
@@ -15724,7 +15898,7 @@ extension Aggregate6Project1<A, B, C, D, E, F, G>
       Expr<F> f,
     )
     aggregateBuilder,
-  ) => _build(aggregateBuilder, AvgExpression._);
+  ) => _build(aggregateBuilder, AvgExpression.internal);
 
   /// Add a `MIN` aggregate function to this [Aggregation].
   ///
@@ -15749,7 +15923,7 @@ extension Aggregate6Project1<A, B, C, D, E, F, G>
       Expr<F> f,
     )
     aggregateBuilder,
-  ) => _build(aggregateBuilder, MinExpression._);
+  ) => _build(aggregateBuilder, MinExpression.internal);
 
   /// Add a `MAX` aggregate function to this [Aggregation].
   ///
@@ -15774,7 +15948,7 @@ extension Aggregate6Project1<A, B, C, D, E, F, G>
       Expr<F> f,
     )
     aggregateBuilder,
-  ) => _build(aggregateBuilder, MaxExpression._);
+  ) => _build(aggregateBuilder, MaxExpression.internal);
 
   /// Add a `COUNT(*)` aggregate function to this [Aggregation].
   ///
@@ -15788,7 +15962,8 @@ extension Aggregate6Project1<A, B, C, D, E, F, G>
     (Expr<A>, Expr<B>, Expr<C>, Expr<D>, Expr<E>, Expr<F>),
     (Expr<G>, Expr<int>)
   >
-  count() => _build((a, b, c, d, e, f) => CountAllExpression._(), (a) => a);
+  count() =>
+      _build((a, b, c, d, e, f) => CountAllExpression.internal(), (a) => a);
 }
 
 /// Extension methods for completing a `GROUP BY`.
@@ -15822,7 +15997,7 @@ extension Group2By6<A, B, C, D, E, F, G, H>
     return Query._(
       _from._context,
       agg._projection,
-      (e) => GroupByClause._(
+      (e) => GroupByClause.internal(
         _from._from(_from._expressions.toList()),
         _handle,
         e.take(6).toList(),
@@ -15891,7 +16066,7 @@ extension Aggregate6Project2<A, B, C, D, E, F, G, H>
       Expr<F> f,
     )
     aggregateBuilder,
-  ) => _build(aggregateBuilder, SumExpression._);
+  ) => _build(aggregateBuilder, SumExpression.internal);
 
   /// Add a `AVG` aggregate function to this [Aggregation].
   ///
@@ -15920,7 +16095,7 @@ extension Aggregate6Project2<A, B, C, D, E, F, G, H>
       Expr<F> f,
     )
     aggregateBuilder,
-  ) => _build(aggregateBuilder, AvgExpression._);
+  ) => _build(aggregateBuilder, AvgExpression.internal);
 
   /// Add a `MIN` aggregate function to this [Aggregation].
   ///
@@ -15945,7 +16120,7 @@ extension Aggregate6Project2<A, B, C, D, E, F, G, H>
       Expr<F> f,
     )
     aggregateBuilder,
-  ) => _build(aggregateBuilder, MinExpression._);
+  ) => _build(aggregateBuilder, MinExpression.internal);
 
   /// Add a `MAX` aggregate function to this [Aggregation].
   ///
@@ -15970,7 +16145,7 @@ extension Aggregate6Project2<A, B, C, D, E, F, G, H>
       Expr<F> f,
     )
     aggregateBuilder,
-  ) => _build(aggregateBuilder, MaxExpression._);
+  ) => _build(aggregateBuilder, MaxExpression.internal);
 
   /// Add a `COUNT(*)` aggregate function to this [Aggregation].
   ///
@@ -15984,7 +16159,8 @@ extension Aggregate6Project2<A, B, C, D, E, F, G, H>
     (Expr<A>, Expr<B>, Expr<C>, Expr<D>, Expr<E>, Expr<F>),
     (Expr<G>, Expr<H>, Expr<int>)
   >
-  count() => _build((a, b, c, d, e, f) => CountAllExpression._(), (a) => a);
+  count() =>
+      _build((a, b, c, d, e, f) => CountAllExpression.internal(), (a) => a);
 }
 
 /// Extension methods for completing a `GROUP BY`.
@@ -16018,7 +16194,7 @@ extension Group1By7<A, B, C, D, E, F, G, H>
     return Query._(
       _from._context,
       agg._projection,
-      (e) => GroupByClause._(
+      (e) => GroupByClause.internal(
         _from._from(_from._expressions.toList()),
         _handle,
         e.take(7).toList(),
@@ -16089,7 +16265,7 @@ extension Aggregate7Project1<A, B, C, D, E, F, G, H>
       Expr<G> g,
     )
     aggregateBuilder,
-  ) => _build(aggregateBuilder, SumExpression._);
+  ) => _build(aggregateBuilder, SumExpression.internal);
 
   /// Add a `AVG` aggregate function to this [Aggregation].
   ///
@@ -16119,7 +16295,7 @@ extension Aggregate7Project1<A, B, C, D, E, F, G, H>
       Expr<G> g,
     )
     aggregateBuilder,
-  ) => _build(aggregateBuilder, AvgExpression._);
+  ) => _build(aggregateBuilder, AvgExpression.internal);
 
   /// Add a `MIN` aggregate function to this [Aggregation].
   ///
@@ -16145,7 +16321,7 @@ extension Aggregate7Project1<A, B, C, D, E, F, G, H>
       Expr<G> g,
     )
     aggregateBuilder,
-  ) => _build(aggregateBuilder, MinExpression._);
+  ) => _build(aggregateBuilder, MinExpression.internal);
 
   /// Add a `MAX` aggregate function to this [Aggregation].
   ///
@@ -16171,7 +16347,7 @@ extension Aggregate7Project1<A, B, C, D, E, F, G, H>
       Expr<G> g,
     )
     aggregateBuilder,
-  ) => _build(aggregateBuilder, MaxExpression._);
+  ) => _build(aggregateBuilder, MaxExpression.internal);
 
   /// Add a `COUNT(*)` aggregate function to this [Aggregation].
   ///
@@ -16185,7 +16361,8 @@ extension Aggregate7Project1<A, B, C, D, E, F, G, H>
     (Expr<A>, Expr<B>, Expr<C>, Expr<D>, Expr<E>, Expr<F>, Expr<G>),
     (Expr<H>, Expr<int>)
   >
-  count() => _build((a, b, c, d, e, f, g) => CountAllExpression._(), (a) => a);
+  count() =>
+      _build((a, b, c, d, e, f, g) => CountAllExpression.internal(), (a) => a);
 }
 
 /// Extensions for a query returning at-most one row with
@@ -16688,7 +16865,7 @@ extension Return1<A> on Return<(Expr<A>,)> {
   Stream<A> executeAndStream() async* {
     final task = _render(_expressions.toList());
     await for (final r in _context._query(task)) {
-      yield _expressions.$1._decode(r) as A;
+      yield _expressions.$1.$decode(r) as A;
     }
   }
 
@@ -16718,7 +16895,10 @@ extension Return2<A, B> on Return<(Expr<A>, Expr<B>)> {
   Stream<(A, B)> executeAndStream() async* {
     final task = _render(_expressions.toList());
     await for (final r in _context._query(task)) {
-      yield (_expressions.$1._decode(r) as A, _expressions.$2._decode(r) as B);
+      yield (
+        _expressions.$1.$decode(r) as A,
+        _expressions.$2.$decode(r) as B,
+      );
     }
   }
 
@@ -16755,9 +16935,9 @@ extension Return3<A, B, C> on Return<(Expr<A>, Expr<B>, Expr<C>)> {
     final task = _render(_expressions.toList());
     await for (final r in _context._query(task)) {
       yield (
-        _expressions.$1._decode(r) as A,
-        _expressions.$2._decode(r) as B,
-        _expressions.$3._decode(r) as C,
+        _expressions.$1.$decode(r) as A,
+        _expressions.$2.$decode(r) as B,
+        _expressions.$3.$decode(r) as C,
       );
     }
   }
@@ -16795,10 +16975,10 @@ extension Return4<A, B, C, D> on Return<(Expr<A>, Expr<B>, Expr<C>, Expr<D>)> {
     final task = _render(_expressions.toList());
     await for (final r in _context._query(task)) {
       yield (
-        _expressions.$1._decode(r) as A,
-        _expressions.$2._decode(r) as B,
-        _expressions.$3._decode(r) as C,
-        _expressions.$4._decode(r) as D,
+        _expressions.$1.$decode(r) as A,
+        _expressions.$2.$decode(r) as B,
+        _expressions.$3.$decode(r) as C,
+        _expressions.$4.$decode(r) as D,
       );
     }
   }
@@ -16839,11 +17019,11 @@ extension Return5<A, B, C, D, E>
     final task = _render(_expressions.toList());
     await for (final r in _context._query(task)) {
       yield (
-        _expressions.$1._decode(r) as A,
-        _expressions.$2._decode(r) as B,
-        _expressions.$3._decode(r) as C,
-        _expressions.$4._decode(r) as D,
-        _expressions.$5._decode(r) as E,
+        _expressions.$1.$decode(r) as A,
+        _expressions.$2.$decode(r) as B,
+        _expressions.$3.$decode(r) as C,
+        _expressions.$4.$decode(r) as D,
+        _expressions.$5.$decode(r) as E,
       );
     }
   }
@@ -16884,12 +17064,12 @@ extension Return6<A, B, C, D, E, F>
     final task = _render(_expressions.toList());
     await for (final r in _context._query(task)) {
       yield (
-        _expressions.$1._decode(r) as A,
-        _expressions.$2._decode(r) as B,
-        _expressions.$3._decode(r) as C,
-        _expressions.$4._decode(r) as D,
-        _expressions.$5._decode(r) as E,
-        _expressions.$6._decode(r) as F,
+        _expressions.$1.$decode(r) as A,
+        _expressions.$2.$decode(r) as B,
+        _expressions.$3.$decode(r) as C,
+        _expressions.$4.$decode(r) as D,
+        _expressions.$5.$decode(r) as E,
+        _expressions.$6.$decode(r) as F,
       );
     }
   }
@@ -16930,13 +17110,13 @@ extension Return7<A, B, C, D, E, F, G>
     final task = _render(_expressions.toList());
     await for (final r in _context._query(task)) {
       yield (
-        _expressions.$1._decode(r) as A,
-        _expressions.$2._decode(r) as B,
-        _expressions.$3._decode(r) as C,
-        _expressions.$4._decode(r) as D,
-        _expressions.$5._decode(r) as E,
-        _expressions.$6._decode(r) as F,
-        _expressions.$7._decode(r) as G,
+        _expressions.$1.$decode(r) as A,
+        _expressions.$2.$decode(r) as B,
+        _expressions.$3.$decode(r) as C,
+        _expressions.$4.$decode(r) as D,
+        _expressions.$5.$decode(r) as E,
+        _expressions.$6.$decode(r) as F,
+        _expressions.$7.$decode(r) as G,
       );
     }
   }
@@ -16995,14 +17175,14 @@ extension Return8<A, B, C, D, E, F, G, H>
     final task = _render(_expressions.toList());
     await for (final r in _context._query(task)) {
       yield (
-        _expressions.$1._decode(r) as A,
-        _expressions.$2._decode(r) as B,
-        _expressions.$3._decode(r) as C,
-        _expressions.$4._decode(r) as D,
-        _expressions.$5._decode(r) as E,
-        _expressions.$6._decode(r) as F,
-        _expressions.$7._decode(r) as G,
-        _expressions.$8._decode(r) as H,
+        _expressions.$1.$decode(r) as A,
+        _expressions.$2.$decode(r) as B,
+        _expressions.$3.$decode(r) as C,
+        _expressions.$4.$decode(r) as D,
+        _expressions.$5.$decode(r) as E,
+        _expressions.$6.$decode(r) as F,
+        _expressions.$7.$decode(r) as G,
+        _expressions.$8.$decode(r) as H,
       );
     }
   }
diff --git a/typed_sql/lib/src/typed_sql.mutation.dart b/typed_sql/lib/src/typed_sql.mutation.dart
index fc9ec167..781a20af 100644
--- a/typed_sql/lib/src/typed_sql.mutation.dart
+++ b/typed_sql/lib/src/typed_sql.mutation.dart
@@ -74,8 +74,8 @@ final class Update<T extends Row> {
   /// Execute this `UPDATE` statement in the database.
   Future<void> execute() async => await _query._context._execute(
     _query._context._dialect.update(
-      UpdateStatement._(
-        TableClause._(_table),
+      UpdateStatement.internal(
+        TableClause.internal(_table),
         _table.columns
             .whereIndexed((index, value) => _set._values[index] != null)
             .toList(),
@@ -99,14 +99,14 @@ final class Update<T extends Row> {
   ) {
     final handle = Object();
     final projection = projectionBuilder(
-      RowExpression._(0, _table, Object())._standin(0, handle),
+      RowExpression.internal(0, _table, Object()).$standin(0, handle),
     );
 
-    final table = TableClause._(_table);
+    final table = TableClause.internal(_table);
 
     return Return._(_query._context, projection, (e) {
       return _query._context._dialect.update(
-        UpdateStatement._(
+        UpdateStatement.internal(
           table,
           table.columns
               .whereIndexed((index, value) => _set._values[index] != null)
@@ -114,7 +114,7 @@ final class Update<T extends Row> {
           _set._values.nonNulls.toList(),
           _handle,
           _query._from(_query._expressions.toList()),
-          ReturningClause._(handle, table.columns, e),
+          ReturningClause.internal(handle, table.columns, e),
         ),
       );
     });
@@ -154,7 +154,7 @@ final class Insert<T extends Row> {
   SqlTask _render({
     ReturningClause? returning,
   }) => _table._context._dialect.insertInto(
-    InsertStatement._(
+    InsertStatement.internal(
       _table._tableClause.name,
       _values,
       _onConflictClause,
@@ -181,14 +181,18 @@ final class Insert<T extends Row> {
   ) {
     final handle = Object();
     final projection = projectionBuilder(
-      _table._expressions.$1._standin(0, handle),
+      _table._expressions.$1.$standin(0, handle),
     );
 
     return Return._(
       _table._context,
       projection,
       (e) => _render(
-        returning: ReturningClause._(handle, _table._tableClause.columns, e),
+        returning: ReturningClause.internal(
+          handle,
+          _table._tableClause.columns,
+          e,
+        ),
       ),
     );
   }
@@ -227,7 +231,7 @@ final class InsertOnConflict<T extends Row> {
   /// This is equivalent to `INSERT ... ON CONFLICT (...) DO NOTHING` in SQL.
   InsertOrIgnore<T> doNothing() => InsertOrIgnore._(
     _insert._with(
-      onConflictClause: DoNothingOnConflictClause._(_conflictTarget),
+      onConflictClause: DoNothingOnConflictClause.internal(_conflictTarget),
     ),
   );
 
@@ -237,20 +241,20 @@ final class InsertOnConflict<T extends Row> {
     final table = _insert._table;
 
     final handle = Object();
-    final row = table._expressions.$1._standin(0, handle);
+    final row = table._expressions.$1.$standin(0, handle);
     final excludedHandle = Object();
-    final excluded = table._expressions.$1._standin(0, excludedHandle);
+    final excluded = table._expressions.$1.$standin(0, excludedHandle);
 
     final set = updateBuilder(row, excluded);
 
     return Upsert._(
       _insert._with(
-        onConflictClause: UpdateOnConflictClause._(
+        onConflictClause: UpdateOnConflictClause.internal(
           handle,
           _conflictTarget,
           table._tableClause,
-          ExpressionContext._(excludedHandle),
-          table._tableClause._definition.columns
+          ExpressionContext.internal(excludedHandle),
+          table._tableClause.columns
               .whereIndexed((index, value) => set._values[index] != null)
               .toList(),
           set._values.nonNulls.toList(),
@@ -379,13 +383,13 @@ final class Upsert<T extends Row> {
     final conflictClause = _insert._onConflictClause as UpdateOnConflictClause;
 
     final expr = _insert._table._expressions.$1;
-    final row = expr._standin(0, conflictClause._handle);
-    final excluded = expr._standin(0, conflictClause.excluded._handle);
+    final row = expr.$standin(0, conflictClause.$handle);
+    final excluded = expr.$standin(0, conflictClause.excluded.$handle);
 
     return UpsertConditional._(
       _insert._with(
-        onConflictClause: UpdateOnConflictClause._(
-          conflictClause._handle,
+        onConflictClause: UpdateOnConflictClause.internal(
+          conflictClause.$handle,
           conflictClause.conflictTarget,
           conflictClause.table,
           conflictClause.excluded,
@@ -497,7 +501,7 @@ final class InsertOnConflictSingle<T extends Row> {
   /// This is equivalent to `INSERT ... ON CONFLICT (...) DO NOTHING` in SQL.
   InsertOrIgnoreSingle<T> doNothing() => InsertOrIgnoreSingle._(
     _insert._with(
-      onConflictClause: DoNothingOnConflictClause._(_conflictTarget),
+      onConflictClause: DoNothingOnConflictClause.internal(_conflictTarget),
     ),
   );
 
@@ -507,20 +511,20 @@ final class InsertOnConflictSingle<T extends Row> {
     final table = _insert._table;
 
     final handle = Object();
-    final row = table._expressions.$1._standin(0, handle);
+    final row = table._expressions.$1.$standin(0, handle);
     final excludedHandle = Object();
-    final excluded = table._expressions.$1._standin(0, excludedHandle);
+    final excluded = table._expressions.$1.$standin(0, excludedHandle);
 
     final set = updateBuilder(row, excluded);
 
     return UpsertSingle._(
       _insert._with(
-        onConflictClause: UpdateOnConflictClause._(
+        onConflictClause: UpdateOnConflictClause.internal(
           handle,
           _conflictTarget,
           table._tableClause,
-          ExpressionContext._(excludedHandle),
-          table._tableClause._definition.columns
+          ExpressionContext.internal(excludedHandle),
+          table._tableClause.columns
               .whereIndexed((index, value) => set._values[index] != null)
               .toList(),
           set._values.nonNulls.toList(),
@@ -652,13 +656,13 @@ final class UpsertSingle<T extends Row> {
     final conflictClause = _insert._onConflictClause as UpdateOnConflictClause;
 
     final expr = _insert._table._expressions.$1;
-    final row = expr._standin(0, conflictClause._handle);
-    final excluded = expr._standin(0, conflictClause.excluded._handle);
+    final row = expr.$standin(0, conflictClause.$handle);
+    final excluded = expr.$standin(0, conflictClause.excluded.$handle);
 
     return UpsertConditionalSingle._(
       _insert._with(
-        onConflictClause: UpdateOnConflictClause._(
-          conflictClause._handle,
+        onConflictClause: UpdateOnConflictClause.internal(
+          conflictClause.$handle,
           conflictClause.conflictTarget,
           conflictClause.table,
           conflictClause.excluded,
@@ -722,8 +726,8 @@ final class Delete<T extends Row> {
   /// Execute this `DELETE` statement in the database.
   Future<void> execute() async => await _query._context._execute(
     _query._context._dialect.delete(
-      DeleteStatement._(
-        TableClause._(_table),
+      DeleteStatement.internal(
+        TableClause.internal(_table),
         _query._from(_query._expressions.toList()),
         null,
       ),
@@ -742,17 +746,17 @@ final class Delete<T extends Row> {
   ) {
     final handle = Object();
     final projection = projectionBuilder(
-      RowExpression._(0, _table, Object())._standin(0, handle),
+      RowExpression.internal(0, _table, Object()).$standin(0, handle),
     );
 
-    final table = TableClause._(_table);
+    final table = TableClause.internal(_table);
 
     return Return._(_query._context, projection, (e) {
       return _query._context._dialect.delete(
-        DeleteStatement._(
+        DeleteStatement.internal(
           table,
           _query._from(_query._expressions.toList()),
-          ReturningClause._(handle, table.columns, e),
+          ReturningClause.internal(handle, table.columns, e),
         ),
       );
     });
diff --git a/typed_sql/lib/src/typed_sql.query.dart b/typed_sql/lib/src/typed_sql.query.dart
index 9529746f..1134d174 100644
--- a/typed_sql/lib/src/typed_sql.query.dart
+++ b/typed_sql/lib/src/typed_sql.query.dart
@@ -73,7 +73,7 @@ final class Table<T extends Row> extends Query<(Expr<T>,)> {
     TableDefinition<T> definition,
   ) : super._(
         context,
-        (RowExpression._(0, definition, Object()),),
+        (RowExpression.internal(0, definition, Object()),),
         (_) => _tableClause,
       );
 }
@@ -286,103 +286,12 @@ final class ProjectedOrderedSubQueryRange<T extends Record> {
   ProjectedOrderedSubQueryRange._(this._query);
 }
 
-/* --------------------- Query clauses ---------------------- */
-
-sealed class QueryClause {}
-
-final class TableClause extends QueryClause {
-  final TableDefinition _definition;
-
-  /// Name of table
-  String get name => _definition.tableName;
-  List<String> get columns => _definition.columns;
-  List<String> get primaryKey => _definition.primaryKey;
-
-  TableClause._(this._definition);
-}
-
-final class SelectClause extends QueryClause {
-  final List<Expr> _expressions;
-
-  Iterable<Expr> get expressions => _expressions.expand((e) => e._explode());
-
-  SelectClause._(this._expressions);
-}
-
-sealed class FromClause extends QueryClause {
-  final QueryClause from;
-  FromClause._(this.from);
-}
-
-/// Interface implemented by object with-in which expressions may exist.
-///
-/// Expressions can be bound to this context, that is the context from which
-/// they are referencing fields.
-final class ExpressionContext {
-  final Object _handle;
-
-  ExpressionContext._(this._handle);
-}
-
-final class SelectFromClause extends FromClause implements ExpressionContext {
-  @override
-  final Object _handle;
-  final List<Expr> _projection;
-
-  Iterable<Expr> get projection => _projection.expand((e) => e._explode());
-
-  SelectFromClause._(super.from, this._handle, this._projection) : super._();
-}
-
-final class WhereClause extends FromClause implements ExpressionContext {
-  @override
-  final Object _handle;
-  final Expr<bool?> where;
-  WhereClause._(super.from, this._handle, this.where) : super._();
-}
-
-final class OrderByClause extends FromClause implements ExpressionContext {
-  @override
-  final Object _handle;
-  final List<(Expr<Comparable?>, Order)> orderBy;
-
-  OrderByClause._(
-    super.from,
-    this._handle,
-    this.orderBy,
-  ) : super._() {
-    if (orderBy.any((e) => e.$1._columns > 1)) {
-      // This shouldn't be possible!
-      throw AssertionError(
-        'In Expr<T extends Row> T may not implement Comparable<T>, '
-        'using Expr<Row> in .orderBy is not supported!',
-      );
-    }
-  }
-}
-
 /// {@category writing_queries}
 enum Order {
   ascending,
   descending,
 }
 
-final class JoinClause extends FromClause implements ExpressionContext {
-  @override
-  final Object _handle;
-  final JoinType type;
-  final QueryClause join;
-  final Expr<bool?> on;
-
-  JoinClause._(
-    this._handle,
-    this.type,
-    super.from,
-    this.join,
-    this.on,
-  ) : super._();
-}
-
 enum JoinType {
   inner,
   left,
@@ -402,117 +311,6 @@ enum JoinType {
   // write such SQL queries manually as SQL.
 }
 
-final class LimitClause extends FromClause {
-  final int limit;
-  LimitClause._(super.from, this.limit) : super._();
-}
-
-final class OffsetClause extends FromClause {
-  final int offset;
-  OffsetClause._(super.from, this.offset) : super._();
-}
-
-final class DistinctClause extends FromClause {
-  DistinctClause._(super.from) : super._();
-}
-
-final class GroupByClause extends FromClause implements ExpressionContext {
-  @override
-  final Object _handle;
-
-  final List<Expr> _group;
-  final List<Expr> _aggregation;
-
-  /// The grouped columns (exploded).
-  late final List<Expr> groupBy = _group.expand((e) => e._explode()).toList();
-
-  /// The projection is made up of the grouped columns followed by the
-  /// aggregations.
-  ///
-  /// We promise that [groupBy] is a prefix of [projection].
-  late final List<Expr> projection = [
-    ...groupBy,
-    ..._aggregation.expand((e) => e._explode()),
-  ];
-
-  GroupByClause._(
-    super.from,
-    this._handle,
-    this._group,
-    this._aggregation,
-  ) : super._();
-}
-
-sealed class CompositeQueryClause extends QueryClause {
-  final QueryClause left;
-  final QueryClause right;
-  CompositeQueryClause._(this.left, this.right);
-}
-
-// make these subclass of composite queryclause
-final class UnionClause extends CompositeQueryClause {
-  UnionClause._(super.left, super.right) : super._();
-}
-
-final class UnionAllClause extends CompositeQueryClause {
-  UnionAllClause._(super.left, super.right) : super._();
-}
-
-final class IntersectClause extends CompositeQueryClause {
-  IntersectClause._(super.left, super.right) : super._();
-}
-
-final class ExceptClause extends CompositeQueryClause {
-  ExceptClause._(super.left, super.right) : super._();
-}
-
-/* --------------------- Auxiliary utils for SQL rendering------------------- */
-
-final class ExpressionResolver<T> {
-  final ExpressionResolver? _parent;
-  final Object _handle;
-  final List<(String?, String)> _columns;
-  final T context;
-
-  /// Depth of the scope in the query tree.
-  final int depth;
-
-  ExpressionResolver._(
-    this.context,
-    this._parent,
-    this._handle,
-    this._columns,
-    this.depth,
-  );
-
-  ExpressionResolver(T context) : this._(context, null, Object(), [], 0);
-
-  ExpressionResolver<T> withScope(
-    ExpressionContext ctx,
-    List<(String?, String)> columns,
-  ) => ExpressionResolver._(
-    context,
-    this,
-    ctx._handle,
-    columns,
-    depth + 1,
-  );
-
-  (String?, String) resolve(FieldExpression field) {
-    if (_handle == field._handle) {
-      return _columns[field._index];
-    }
-    if (_parent != null) {
-      return _parent.resolve(field);
-    }
-    throw ArgumentError.value(
-      field,
-      'field',
-      'cannot be resolved in the given context',
-    );
-  }
-}
-
 /* --------------------- GroupBy / Aggregation ------------------- */
 
 /// {@category aggregate_functions}
diff --git a/typed_sql/lib/src/typed_sql.query_ext.dart b/typed_sql/lib/src/typed_sql.query_ext.dart
index 41393265..f4b1fb43 100644
--- a/typed_sql/lib/src/typed_sql.query_ext.dart
+++ b/typed_sql/lib/src/typed_sql.query_ext.dart
@@ -19,7 +19,7 @@ extension QuerySingle1AsExpr<T> on QuerySingle<(Expr<T>,)> {
   /// Use this [QuerySingle] as subquery expression.
   ///
   /// This is equivalent to `(SELECT * FROM this LIMIT 1)` in SQL.
-  Expr<T?> get asExpr => SubQueryExpression._(
+  Expr<T?> get asExpr => SubQueryExpression.internal(
     _query._from(_query._expressions.toList()),
     _query._expressions.$1,
   );
@@ -34,8 +34,8 @@ extension SubQuery1Ext<T> on SubQuery<(Expr<T>,)> {
   ///
   /// This is equivalent to `(SELECT * FROM this LIMIT 1)` in SQL.
   /// {@endtemplate}
-  Expr<T?> get first => SubQueryExpression._(
-    LimitClause._(_from(_expressions.toList()), 1),
+  Expr<T?> get first => SubQueryExpression.internal(
+    LimitClause.internal(_from(_expressions.toList()), 1),
     _expressions.$1,
   );
 }
@@ -79,7 +79,8 @@ extension QueryInteger on Query<(Expr<int?>,)> {
   /// > zero, if there are no rows, or all if all rows are `NULL`.
   /// > Where as `SUM` in SQL would return `NULL`.
   /// {@endtemplate}
-  QuerySingle<(Expr<int>,)> sum() => select((a) => (SumExpression._(a),)).first;
+  QuerySingle<(Expr<int>,)> sum() =>
+      select((a) => (SumExpression.internal(a),)).first;
 
   /// {@template avg-query}
   /// Take the average of the rows in this query using the `AVG`
@@ -93,7 +94,7 @@ extension QueryInteger on Query<(Expr<int?>,)> {
   /// > Similarly, `NULL` rows will not figure in the average value.
   /// {@endtemplate}
   QuerySingle<(Expr<double?>,)> avg() =>
-      select((a) => (AvgExpression._(a),)).first;
+      select((a) => (AvgExpression.internal(a),)).first;
 
   /// {@template min-query}
   /// Take the smallest row of the rows in this query using the `MIN`
@@ -106,7 +107,7 @@ extension QueryInteger on Query<(Expr<int?>,)> {
   /// > `NULL` if there are no rows or if all rows are `NULL`.
   /// {@endtemplate}
   QuerySingle<(Expr<int?>,)> min() =>
-      select((a) => (MinExpression._(a),)).first;
+      select((a) => (MinExpression.internal(a),)).first;
 
   /// {@template max-query}
   /// Take the largest row of the rows in this query using the `MAX`
@@ -119,96 +120,98 @@ extension QueryInteger on Query<(Expr<int?>,)> {
   /// > `NULL` if there are no rows or if all rows are `NULL`.
   /// {@endtemplate}
   QuerySingle<(Expr<int?>,)> max() =>
-      select((a) => (MaxExpression._(a),)).first;
+      select((a) => (MaxExpression.internal(a),)).first;
 }
 
 /// Extension methods for queries projected to a [double] expression.
 extension QueryReal on Query<(Expr<double?>,)> {
   /// {@macro sum-query}
   QuerySingle<(Expr<double>,)> sum() =>
-      select((a) => (SumExpression._(a),)).first;
+      select((a) => (SumExpression.internal(a),)).first;
 
   /// {@macro avg-query}
   QuerySingle<(Expr<double?>,)> avg() =>
-      select((a) => (AvgExpression._(a),)).first;
+      select((a) => (AvgExpression.internal(a),)).first;
 
   /// {@macro min-query}
   QuerySingle<(Expr<double?>,)> min() =>
-      select((a) => (MinExpression._(a),)).first;
+      select((a) => (MinExpression.internal(a),)).first;
 
   /// {@macro max-query}
   QuerySingle<(Expr<double?>,)> max() =>
-      select((a) => (MaxExpression._(a),)).first;
+      select((a) => (MaxExpression.internal(a),)).first;
 }
 
 /// Extension methods for queries projected to a [DateTime] expression.
 extension QueryDateTime on Query<(Expr<DateTime?>,)> {
   /// {@macro min-query}
   QuerySingle<(Expr<DateTime?>,)> min() =>
-      select((a) => (MinExpression._(a),)).first;
+      select((a) => (MinExpression.internal(a),)).first;
 
   /// {@macro max-query}
   QuerySingle<(Expr<DateTime?>,)> max() =>
-      select((a) => (MaxExpression._(a),)).first;
+      select((a) => (MaxExpression.internal(a),)).first;
 }
 
 /// Extension methods for queries projected to a [String] expression.
 extension QueryString on Query<(Expr<String?>,)> {
   /// {@macro min-query}
   QuerySingle<(Expr<String?>,)> min() =>
-      select((a) => (MinExpression._(a),)).first;
+      select((a) => (MinExpression.internal(a),)).first;
 
   /// {@macro max-query}
   QuerySingle<(Expr<String?>,)> max() =>
-      select((a) => (MaxExpression._(a),)).first;
+      select((a) => (MaxExpression.internal(a),)).first;
 }
 
 /// Extension methods for subqueries projected to an [int] expression.
 extension SubQueryInteger on SubQuery<(Expr<int?>,)> {
   /// {@macro sum-query}
-  Expr<int> sum() => select((a) => (SumExpression._(a),)).first.asNotNull();
+  Expr<int> sum() =>
+      select((a) => (SumExpression.internal(a),)).first.asNotNull();
 
   /// {@macro avg-query}
-  Expr<double?> avg() => select((a) => (AvgExpression._(a),)).first;
+  Expr<double?> avg() => select((a) => (AvgExpression.internal(a),)).first;
 
   /// {@macro min-query}
-  Expr<int?> min() => select((a) => (MinExpression._(a),)).first;
+  Expr<int?> min() => select((a) => (MinExpression.internal(a),)).first;
 
   /// {@macro max-query}
-  Expr<int?> max() => select((a) => (MaxExpression._(a),)).first;
+  Expr<int?> max() => select((a) => (MaxExpression.internal(a),)).first;
 }
 
 /// Extension methods for subqueries projected to a [double] expression.
 extension SubQueryReal on SubQuery<(Expr<double?>,)> {
   /// {@macro sum-query}
-  Expr<double> sum() => select((a) => (SumExpression._(a),)).first.asNotNull();
+  Expr<double> sum() =>
+      select((a) => (SumExpression.internal(a),)).first.asNotNull();
 
   /// {@macro avg-query}
-  Expr<double?> avg() => select((a) => (AvgExpression._(a),)).first;
+  Expr<double?> avg() => select((a) => (AvgExpression.internal(a),)).first;
 
   /// {@macro min-query}
-  Expr<double?> min() => select((a) => (MinExpression._(a),)).first;
+  Expr<double?> min() => select((a) => (MinExpression.internal(a),)).first;
 
   /// {@macro max-query}
-  Expr<double?> max() => select((a) => (MaxExpression._(a),)).first;
+  Expr<double?> max() => select((a) => (MaxExpression.internal(a),)).first;
 }
 
 /// Extension methods for subqueries projected to a [DateTime] expression.
 extension SubQueryDateTime on SubQuery<(Expr<DateTime?>,)> {
   /// {@macro min-query}
-  Expr<DateTime?> min() => select((a) => (MinExpression._(a),)).first;
+  Expr<DateTime?> min() => select((a) => (MinExpression.internal(a),)).first;
 
   /// {@macro max-query}
-  Expr<DateTime?> max() => select((a) => (MaxExpression._(a),)).first;
+  Expr<DateTime?> max() => select((a) => (MaxExpression.internal(a),)).first;
 }
 
 /// Extension methods for subqueries projected to a [String] expression.
 extension SubQueryString on SubQuery<(Expr<String?>,)> {
   /// {@macro min-query}
-  Expr<String?> min() => select((a) => (MinExpression._(a),)).first;
+  Expr<String?> min() => select((a) => (MinExpression.internal(a),)).first;
 
   /// {@macro max-query}
-  Expr<String?> max() => select((a) => (MaxExpression._(a),)).first;
+  Expr<String?> max() => select((a) => (MaxExpression.internal(a),)).first;
 }
 
 /// Extension methods for all queries.
@@ -220,7 +223,7 @@ extension QueryExt<T extends Record> on Query<T> {
   /// This is equivalent to `SELECT DISTINCT * FROM this` in SQL.
   /// {@endtemplate}
   Query<T> distinct() =>
-      Query._(_context, _expressions, (e) => DistinctClause._(_from(e)));
+      Query._(_context, _expressions, (e) => DistinctClause.internal(_from(e)));
 
   /// Use this [Query] as a [SubQuery].
   ///
@@ -281,7 +284,7 @@ extension ProjectedOrderedQueryRangeExt<T extends Record>
 extension QuerySubExt<T extends Record> on SubQuery<T> {
   /// {@macro distinct-query}
   SubQuery<T> distinct() =>
-      SubQuery._(_expressions, (e) => DistinctClause._(_from(e)));
+      SubQuery._(_expressions, (e) => DistinctClause.internal(_from(e)));
 }
 
 /// {@template OrderedSubQueryExt}
diff --git a/typed_sql/lib/typed_sql.dart b/typed_sql/lib/typed_sql.dart
index e6a06843..0fb28325 100644
--- a/typed_sql/lib/typed_sql.dart
+++ b/typed_sql/lib/typed_sql.dart
@@ -23,83 +23,15 @@
 library;
 
 export 'src/adapter/adapter.dart' show DatabaseAdapter, RowReader;
+export 'src/ast.expr.dart' show Expr, toExpr, toExprLiteral;
 export 'src/dialect/dialect.dart' show SqlDialect;
 export 'src/exceptions.dart' hide throwTransactionAbortedException;
 export 'src/typed_sql.dart'
     hide
-        AvgExpression,
-        BinaryOperationExpression,
-        CastExpression,
         ColumnDefinition,
-        ColumnType,
-        CompositeQueryClause,
-        ConflictClause,
-        CountAllExpression,
-        CreateTableStatement,
-        CustomExprType,
-        DeleteStatement,
-        DistinctClause,
-        DoNothingOnConflictClause,
-        EncodedCustomDataTypeExpression,
-        ExceptClause,
-        ExistsExpression,
-        ExpressionBoolAnd,
-        ExpressionBoolNot,
-        ExpressionBoolOr,
-        ExpressionContext,
-        ExpressionEquals,
-        ExpressionGreaterThan,
-        ExpressionGreaterThanOrEqual,
-        ExpressionLessThan,
-        ExpressionLessThanOrEqual,
-        ExpressionNumAdd,
-        ExpressionNumDivide,
-        ExpressionNumMultiply,
-        ExpressionNumSubtract,
-        ExpressionResolver,
-        ExpressionStringContains,
-        ExpressionStringEndsWith,
-        ExpressionStringIsEmpty,
-        ExpressionStringLength,
-        ExpressionStringLike,
-        ExpressionStringStartsWith,
-        ExpressionStringToLowerCase,
-        ExpressionStringToUpperCase,
-        FieldExpression,
-        FieldType,
         ForeignKeyDefinition,
-        FromClause,
-        GroupByClause,
         IndexDefinition,
-        InsertStatement,
-        IntersectClause,
-        JoinClause,
         JoinType,
-        LimitClause,
-        LiteralExpression,
-        MaxExpression,
-        MinExpression,
-        NotNullExpression,
-        OffsetClause,
-        OrElseExpression,
-        OrderByClause,
-        QueryClause,
-        ReturningClause,
-        RowExpression,
-        SelectClause,
-        SelectFromClause,
-        SelectStatement,
-        SingleValueExpr,
-        SqlStatement,
-        SubQueryExpression,
-        SumExpression,
-        TableClause,
-        TableDefinition,
-        UnionAllClause,
-        UnionClause,
-        UpdateOnConflictClause,
-        UpdateStatement,
-        ValueExpression,
-        WhereClause;
+        TableDefinition;
 export 'src/types/custom_data_type.dart' show CustomDataType;
 export 'src/types/json_value.dart' show JsonValue;