Remove references to moor in pkg:drift

drift/lib/extensions/native.dart

@@ -11,7 +11,7 @@ import '../drift.dart';
 /// This function is equivalent to [pow], except that it evaluates to null
 /// instead of `NaN`.
 ///
-/// This function is only available when using `moor_ffi`.
+/// This function is only available when using a `NativeDatabase`.
 Expression<num?> sqlPow(Expression<num?> base, Expression<num?> exponent) {
   return FunctionCallExpression('pow', [base, exponent]);
 }
@@ -21,7 +21,7 @@ Expression<num?> sqlPow(Expression<num?> base, Expression<num?> exponent) {
 /// This function is equivalent to [sqrt], except that it returns null instead
 /// of `NaN` for negative values.
 ///
-/// This function is only available when using `moor_ffi`.
+/// This function is only available when using a `NativeDatabase`.
 Expression<num?> sqlSqrt(Expression<num?> value) {
   return FunctionCallExpression('sqrt', [value]);
 }
@@ -30,7 +30,7 @@ Expression<num?> sqlSqrt(Expression<num?> value) {
 ///
 /// This function is equivalent to [sin].
 ///
-/// This function is only available when using `moor_ffi`.
+/// This function is only available when using a `NativeDatabase`.
 Expression<num?> sqlSin(Expression<num?> value) {
   return FunctionCallExpression('sin', [value]);
 }
@@ -39,7 +39,7 @@ Expression<num?> sqlSin(Expression<num?> value) {
 ///
 /// This function is equivalent to [sin].
 ///
-/// This function is only available when using `moor_ffi`.
+/// This function is only available when using a `NativeDatabase`.
 Expression<num?> sqlCos(Expression<num?> value) {
   return FunctionCallExpression('cos', [value]);
 }
@@ -48,7 +48,7 @@ Expression<num?> sqlCos(Expression<num?> value) {
 ///
 /// This function is equivalent to [tan].
 ///
-/// This function is only available when using `moor_ffi`.
+/// This function is only available when using a `NativeDatabase`.
 Expression<num?> sqlTan(Expression<num?> value) {
   return FunctionCallExpression('tan', [value]);
 }
@@ -58,7 +58,7 @@ Expression<num?> sqlTan(Expression<num?> value) {
 /// This function is equivalent to [asin], except that it evaluates to null
 /// instead of `NaN`.
 ///
-/// This function is only available when using `moor_ffi`.
+/// This function is only available when using a `NativeDatabase`.
 Expression<num?> sqlAsin(Expression<num?> value) {
   return FunctionCallExpression('asin', [value]);
 }
@@ -68,7 +68,7 @@ Expression<num?> sqlAsin(Expression<num?> value) {
 /// This function is equivalent to [acos], except that it evaluates to null
 /// instead of `NaN`.
 ///
-/// This function is only available when using `moor_ffi`.
+/// This function is only available when using a `NativeDatabase`.
 Expression<num?> sqlAcos(Expression<num?> value) {
   return FunctionCallExpression('acos', [value]);
 }
@@ -78,14 +78,14 @@ Expression<num?> sqlAcos(Expression<num?> value) {
 /// This function is equivalent to [atan], except that it evaluates to null
 /// instead of `NaN`.
 ///
-/// This function is only available when using `moor_ffi`.
+/// This function is only available when using a `NativeDatabase`.
 Expression<num?> sqlAtan(Expression<num?> value) {
   return FunctionCallExpression('atan', [value]);
 }
 
 /// Adds functionality to string expressions that only work when using
-/// `moor_ffi`.
+/// a `NativeDatabase`.
-extension MoorFfiSpecificStringExtensions on Expression<String?> {
+extension DriftNativeStringExtensions on Expression<String?> {
   /// Version of `contains` that allows controlling case sensitivity better.
   ///
   /// The default `contains` method uses sqlite's `LIKE`, which is case-
@@ -100,9 +100,6 @@ extension MoorFfiSpecificStringExtensions on Expression<String?> {
   /// Note that, while Dart has better support for an international alphabet,
   /// it can still yield unexpected results like the
   /// [Turkish İ Problem](https://haacked.com/archive/2012/07/05/turkish-i-problem-and-why-you-should-care.aspx/)
-  ///
-  /// Note that this is only available when using `moor_ffi` version 0.6.0 or
-  /// greater.
   Expression<bool?> containsCase(String substring,
       {bool caseSensitive = false}) {
     return FunctionCallExpression('moor_contains', [

drift/lib/isolate.dart

@@ -1,5 +1,6 @@
-/// Contains utils to run moor databases in a background isolate. This API is
+/// Contains utils to run drift databases in a background isolate.
-/// not supported on the web.
+///
+/// Please note that this API is not supported on the web.
 library isolate;
 
 import 'dart:isolate';
@@ -13,14 +14,14 @@ import 'src/isolate.dart';
 /// Signature of a function that opens a database connection.
 typedef DatabaseOpener = DatabaseConnection Function();
 
-/// Defines utilities to run moor in a background isolate. In the operation mode
+/// Defines utilities to run drift in a background isolate. In the operation
-/// created by these utilities, there's a single background isolate doing all
+/// mode created by these utilities, there's a single background isolate doing
-/// the work. Any other isolate can use the [connect] method to obtain an
+/// all the work. Any other isolate can use the [connect] method to obtain an
 /// instance of a [GeneratedDatabase] class that will delegate its work onto a
 /// background isolate. Auto-updating queries, and transactions work across
 /// isolates, and the user facing api is exactly the same.
 ///
-/// Please note that, while running moor in a background isolate can reduce
+/// Please note that, while running drift in a background isolate can reduce
 /// latency in foreground isolates (thus reducing UI lags), the overall
 /// performance is going to be much worse as data has to be serialized and
 /// deserialized to be sent over isolates.
@@ -28,7 +29,7 @@ typedef DatabaseOpener = DatabaseConnection Function();
 ///
 /// See also:
 /// - [Isolate], for general information on multi threading in Dart.
-/// - The [detailed documentation](https://moor.simonbinder.eu/docs/advanced-features/isolates),
+/// - The [detailed documentation](https://drift.simonbinder.eu/docs/advanced-features/isolates),
 ///   which provides example codes on how to use this api.
 class DriftIsolate {
   /// The underlying port used to establish a connection with this
@@ -43,7 +44,7 @@ class DriftIsolate {
   DriftIsolate.fromConnectPort(this.connectPort);
 
   StreamChannel _open() {
-    final receive = ReceivePort('moor client receive');
+    final receive = ReceivePort('drift client receive');
     connectPort.send(receive.sendPort);
 
     final controller =
@@ -65,7 +66,7 @@ class DriftIsolate {
   ///
   /// All operations on the returned [DatabaseConnection] will be executed on a
   /// background isolate. Setting the [isolateDebugLog] is only helpful when
-  /// debugging moor itself.
+  /// debugging drift itself.
   // todo: breaking: Make synchronous in drift 5
   Future<DatabaseConnection> connect({bool isolateDebugLog = false}) async {
     return remote(_open(), debugLog: isolateDebugLog);
@@ -94,7 +95,7 @@ class DriftIsolate {
     final receiveServer = ReceivePort();
     final keyFuture = receiveServer.first;
 
-    await Isolate.spawn(_startMoorIsolate, [receiveServer.sendPort, opener]);
+    await Isolate.spawn(_startDriftIsolate, [receiveServer.sendPort, opener]);
     final key = await keyFuture as SendPort;
     return DriftIsolate.fromConnectPort(key);
   }
@@ -109,23 +110,23 @@ class DriftIsolate {
   /// to call [DriftIsolate.inCurrent] will be killed.
   factory DriftIsolate.inCurrent(DatabaseOpener opener,
       {bool killIsolateWhenDone = false}) {
-    final server = RunningMoorServer(Isolate.current, opener(),
+    final server = RunningDriftServer(Isolate.current, opener(),
         killIsolateWhenDone: killIsolateWhenDone);
     return DriftIsolate.fromConnectPort(server.portToOpenConnection);
   }
 }
 
-/// Creates a [RunningMoorServer] and sends a [SendPort] that can be used to
+/// Creates a [RunningDriftServer] and sends a [SendPort] that can be used to
 /// establish connections.
 ///
 /// Te [args] list must contain two elements. The first one is the [SendPort]
-/// that [_startMoorIsolate] will use to send the new [SendPort] used to
+/// that [_startDriftIsolate] will use to send the new [SendPort] used to
 /// establish further connections. The second element is a [DatabaseOpener]
 /// used to open the underlying database connection.
-void _startMoorIsolate(List args) {
+void _startDriftIsolate(List args) {
   final sendPort = args[0] as SendPort;
   final opener = args[1] as DatabaseOpener;
 
-  final server = RunningMoorServer(Isolate.current, opener());
+  final server = RunningDriftServer(Isolate.current, opener());
   sendPort.send(server.portToOpenConnection);
 }

drift/lib/native.dart

@@ -1,11 +1,13 @@
-/// Moor implementation using `package:sqlite3/`.
+/// A drift database implementation built on `package:sqlite3/`.
+///
+/// The [NativeDatabase] class uses `dart:ffi` to access `sqlite3` APIs.
 ///
 /// When using a [NativeDatabase], you need to ensure that `sqlite3` is
 /// available when running your app. For mobile Flutter apps, you can simply
 /// depend on the `sqlite3_flutter_libs` package to ship the latest sqlite3
 /// version with your app.
 /// For more information other platforms, see [other engines](https://drift.simonbinder.eu/docs/other-engines/vm/).
-library moor.ffi;
+library drift.ffi;
 
 import 'src/ffi/database.dart';
 

drift/lib/remote.dart

@@ -28,7 +28,7 @@
 /// However, note that drift might encode a `List<int>` as `Uint8List`. For
 /// performance reasons, channel implementations should preserve this.
 ///
-/// Moor assumes full control over the [StreamChannel]s it manages. For this
+/// Drift assumes full control over the [StreamChannel]s it manages. For this
 /// reason, do not send your own messages over them or close them prematurely.
 /// If you need further channels over the same underlying connection, consider a
 /// [MultiChannel] instead.
@@ -88,7 +88,7 @@ abstract class DriftServer {
   /// Starts processing requests from the [channel].
   ///
   /// The [channel] uses a drift-internal protocol to serialize database
-  /// requests. Moor assumes full control over the [channel]. Manually sending
+  /// requests. Drift assumes full control over the [channel]. Manually sending
   /// messages over it, or closing it prematurely, can disrupt the server.
   ///
   /// __Warning__: As long as this library is marked experimental, the protocol
@@ -115,7 +115,7 @@ abstract class DriftServer {
 /// messages.
 DatabaseConnection remote(StreamChannel<Object?> channel,
     {bool debugLog = false}) {
-  final client = MoorClient(channel, debugLog);
+  final client = DriftClient(channel, debugLog);
   return client.connection;
 }
 
@@ -125,6 +125,6 @@ DatabaseConnection remote(StreamChannel<Object?> channel,
 /// [DriftServer.serve] for this setup to work.
 /// Also, the [DriftServer] must have been configured to allow remote-shutdowns.
 Future<void> shutdown(StreamChannel<Object?> channel) {
-  final comm = MoorCommunication(channel);
+  final comm = DriftCommunication(channel);
   return comm.request(NoArgsRequest.terminateAll);
 }

drift/lib/sqlite_keywords.dart

@@ -2,7 +2,7 @@
 library drift.sqlite_keywords;
 
 /// Contains a set of all sqlite keywords, according to
-/// https://www.sqlite.org/lang_keywords.html. Moor will use this list to
+/// https://www.sqlite.org/lang_keywords.html. Drift will use this list to
 /// escape keywords.
 const sqliteKeywords = {
   'ADD',

drift/lib/src/dsl/columns.dart

@@ -38,12 +38,12 @@ typedef RealColumn = Column<double?>;
 
 /// A column builder is used to specify which columns should appear in a table.
 /// All of the methods defined in this class and its subclasses are not meant to
-/// be called at runtime. Instead, moor_generator will take a look at your
+/// be called at runtime. Instead, the generator will take a look at your
 /// source code (specifically, it will analyze which of the methods you use) to
 /// figure out the column structure of a table.
 class ColumnBuilder<T> {}
 
-/// DSL extension to define a column with moor.
+/// DSL extension to define a column inside a drift table.
 extension BuildColumn<T> on ColumnBuilder<T> {
   /// By default, the field name will be used as the column name, e.g.
   /// `IntColumn get id = integer()` will have "id" as its associated name.
@@ -62,7 +62,7 @@ extension BuildColumn<T> on ColumnBuilder<T> {
   /// primary key. Columns are non-null by default.
   ColumnBuilder<T?> nullable() => _isGenerated();
 
-  /// Tells moor to write a custom constraint after this column definition when
+  /// Tells drift to write a custom constraint after this column definition when
   /// writing this column, for instance in a CREATE TABLE statement.
   ///
   /// When no custom constraint is set, columns will be written like this:
@@ -78,9 +78,9 @@ extension BuildColumn<T> on ColumnBuilder<T> {
   /// nullability information is lost - you'll have to include it in
   /// [constraint] if that is desired.
   ///
-  /// This can be used to implement constraints that moor does not (yet)
+  /// This can be used to implement constraints that drift does not (yet)
   /// support (e.g. unique keys, etc.). If you've found a common use-case for
-  /// this, it should be considered a limitation of moor itself. Please feel
+  /// this, it should be considered a limitation of drift itself. Please feel
   /// free to open an issue at https://github.com/simolus3/moor/issues/new to
   /// report that.
   ///
@@ -178,7 +178,7 @@ extension BuildColumn<T> on ColumnBuilder<T> {
       _isGenerated();
 
   /// Turns this column builder into a column. This method won't actually be
-  /// called in your code. Instead, moor_generator will take a look at your
+  /// called in your code. Instead, the generator will take a look at your
   /// source code to figure out your table structure.
   Column<T> call() => _isGenerated();
 }
@@ -227,7 +227,7 @@ class JsonKey {
   /// for [JsonKey] for details.
   final String key;
 
-  /// An annotation to tell moor how the name of a column should appear in
+  /// An annotation to tell drift how the name of a column should appear in
   /// generated json. See the documentation for [JsonKey] for details.
   const JsonKey(this.key);
 }

drift/lib/src/dsl/database.dart

@@ -1,14 +1,14 @@
 part of 'dsl.dart';
 
-/// Use this class as an annotation to inform moor_generator that a database
+/// Use this class as an annotation to inform the generator that a database
 /// class should be generated using the specified [DriftDatabase.tables].
 ///
 /// To write a database class, first annotate an empty class with
 /// [DriftDatabase] and run the build runner using
 /// `dart pub run build_runner build`.
-/// Moor will have generated a class that has the same name as your database
+/// Drift will have generated a class that has the same name as your database
 /// class, but with `_$` as a prefix. You can now extend that class and provide
-/// a [QueryExecutor] to use moor:
+/// a [QueryExecutor] to use drift:
 /// ```dart
 /// class MyDatabase extends _$MyDatabase { // _$MyDatabase was generated
 ///   MyDatabase():
@@ -27,33 +27,34 @@ class DriftDatabase {
   /// [DriftAccessor].
   final List<Type> daos;
 
-  /// {@template moor_compile_queries_param}
+  /// {@template drift_compile_queries_param}
-  /// Optionally, a list of named sql queries. During a build, moor will look at
+  /// Optionally, a list of named sql queries. During a build, drift will look
-  /// the defined sql, figure out what they do, and write appropriate
+  /// at the defined sql, figure out what they do, and write appropriate
   /// methods in your generated database.
   ///
   /// For instance, when using
   /// ```dart
-  /// @UseMoor(
+  /// @DriftDatabase(
   ///   tables: [Users],
   ///   queries: {
   ///     'userById': 'SELECT * FROM users WHERE id = ?',
   ///   },
   /// )
   /// ```
-  /// Moor will generate two methods for you: `userById(int id)` and
+  /// Drift will generate two methods for you: `userById(int id)` and
   /// `watchUserById(int id)`.
   /// {@endtemplate}
   final Map<String, String> queries;
 
-  /// {@template moor_include_param}
+  /// {@template drift_compile_queries_param}
-  /// Defines the `.moor` files to include when building the table structure for
+  ///
-  /// this database. For details on how to integrate `.moor` files into your
+  /// Defines the `.drift` files to include when building the table structure
-  /// Dart code, see [the documentation](https://moor.simonbinder.eu/docs/using-sql/custom_tables/).
+  /// for this database. For details on how to integrate `.drift` files into
+  /// your Dart code, see [the documentation](https://drift.simonbinder.eu/docs/using-sql/custom_tables/).
   /// {@endtemplate}
   final Set<String> include;
 
-  /// Use this class as an annotation to inform moor_generator that a database
+  /// Use this class as an annotation to inform the generator that a database
   /// class should be generated using the specified [DriftDatabase.tables].
   const DriftDatabase({
     this.tables = const [],
@@ -77,7 +78,7 @@ class DriftDatabase {
 ///   MyDao(MyDatabase db) : super(db);
 /// }
 /// ```
-/// After having run the build step once more, moor will have generated a mixin
+/// After having run the build step once more, drift will have generated a mixin
 /// called `_$MyDaoMixin`. Change your class definition to
 /// `class MyDao extends DatabaseAccessor<MyDatabase> with _$MyDaoMixin` and
 /// you're ready to make queries inside your dao. You can obtain an instance of
@@ -85,21 +86,22 @@ class DriftDatabase {
 /// class.
 ///
 /// See also:
-/// - https://moor.simonbinder.eu/daos/
+/// - https://drift.simonbinder.eu/daos/
 class DriftAccessor {
   /// The tables accessed by this DAO.
   final List<Type> tables;
 
-  /// {@macro moor_compile_queries_param}
+  /// {@macro drift_compile_queries_param}
   final Map<String, String> queries;
 
-  /// {@macro moor_include_param}
+  /// {@macro drift_include_param}
   final Set<String> include;
 
-  /// Annotation for a class to declare it as an dao. See [UseDao] and the
+  /// Annotation for a class to declare it as an dao. See [DriftAccessor] and
-  /// referenced documentation on how to use daos with moor.
+  /// the referenced documentation on how to use daos with drift.
-  const DriftAccessor(
+  const DriftAccessor({
-      {this.tables = const [],
+    this.tables = const [],
-      this.queries = const {},
+    this.queries = const {},
-      this.include = const {}});
+    this.include = const {},
+  });
 }

drift/lib/src/dsl/table.dart

@@ -6,12 +6,12 @@ abstract class HasResultSet {
   const HasResultSet();
 }
 
-/// Subclasses represent a table in a database generated by moor.
+/// Subclasses represent a table in a database generated by drift.
 abstract class Table extends HasResultSet {
-  /// Defines a table to be used with moor.
+  /// Defines a table to be used with drift.
   const Table();
 
-  /// The sql table name to be used. By default, moor will use the snake_case
+  /// The sql table name to be used. By default, drift will use the snake_case
   /// representation of your class name as the sql table name. For instance, a
   /// [Table] class named `LocalSettings` will be called `local_settings` by
   /// default.
@@ -27,7 +27,7 @@ abstract class Table extends HasResultSet {
   /// statement. This is intended to be used by generated code only.
   bool get withoutRowId => false;
 
-  /// Moor will write some table constraints automatically, for instance when
+  /// Drift will write some table constraints automatically, for instance when
   /// you override [primaryKey]. You can turn this behavior off if you want to.
   /// This is intended to be used by generated code only.
   bool get dontWriteConstraints => false;
@@ -45,10 +45,10 @@ abstract class Table extends HasResultSet {
   ///}
   /// ```
   /// The getter must return a set literal using the `=>` syntax so that the
-  /// moor generator can understand the code.
+  /// drift generator can understand the code.
   /// Also, please note that it's an error to have an
   /// [BuildIntColumn.autoIncrement] column and a custom primary key.
-  /// As an auto-incremented `IntColumn` is recognized by moor to be the
+  /// As an auto-incremented `IntColumn` is recognized by drift to be the
   /// primary key, doing so will result in an exception thrown at runtime.
   @visibleForOverriding
   Set<Column>? get primaryKey => null;
@@ -121,8 +121,8 @@ abstract class Table extends HasResultSet {
 /// A class to be used as an annotation on [Table] classes to customize the
 /// name for the data class that will be generated for the table class. The data
 /// class is a dart object that will be used to represent a row in the table.
-/// {@template moor_custom_data_class}
+/// {@template drift_custom_data_class}
-/// By default, moor will attempt to use the singular form of the table name
+/// By default, drift will attempt to use the singular form of the table name
 /// when naming data classes (e.g. a table named "Users" will generate a data
 /// class called "User"). However, this doesn't work for irregular plurals and
 /// you might want to choose a different name, for which this annotation can be
@@ -131,11 +131,11 @@ abstract class Table extends HasResultSet {
 @Target({TargetKind.classType})
 class DataClassName {
   /// The overridden name to use when generating the data class for a table.
-  /// {@macro moor_custom_data_class}
+  /// {@macro drift_custom_data_class}
   final String name;
 
   /// Customize the data class name for a given table.
-  /// {@macro moor_custom_data_class}
+  /// {@macro drift_custom_data_class}
   const DataClassName(this.name);
 }
 
@@ -155,7 +155,7 @@ class UseRowClass {
   /// used to map database rows to the desired row class.
   final String constructor;
 
-  /// Customize the class used by moor to hold an instance of an annotated
+  /// Customize the class used by drift to hold an instance of an annotated
   /// table.
   ///
   /// For details, see the overall documentation on [UseRowClass].

drift/lib/src/ffi/database.dart

@@ -5,16 +5,16 @@ import 'package:sqlite3/sqlite3.dart';
 
 import '../../backends.dart';
 import 'database_tracker.dart';
-import 'moor_ffi_functions.dart';
+import 'native_functions.dart';
 
 /// Signature of a function that can perform setup work on a [database] before
-/// moor is fully ready.
+/// drift is fully ready.
 ///
 /// This could be used to, for instance, set encryption keys for SQLCipher
 /// implementations.
 typedef DatabaseSetup = void Function(Database database);
 
-/// A moor database implementation based on `dart:ffi`, running directly in a
+/// A drift database implementation based on `dart:ffi`, running directly in a
 /// Dart VM or an AOT compiled Dart/Flutter application.
 class NativeDatabase extends DelegatedDatabase {
   NativeDatabase._(DatabaseDelegate delegate, bool logStatements)
@@ -23,11 +23,11 @@ class NativeDatabase extends DelegatedDatabase {
   /// Creates a database that will store its result in the [file], creating it
   /// if it doesn't exist.
   ///
-  /// {@template moor_vm_database_factory}
+  /// {@template drift_vm_database_factory}
   /// If [logStatements] is true (defaults to `false`), generated sql statements
   /// will be printed before executing. This can be useful for debugging.
   /// The optional [setup] function can be used to perform a setup just after
-  /// the database is opened, before moor is fully ready. This can be used to
+  /// the database is opened, before drift is fully ready. This can be used to
   /// add custom user-defined sql functions or to provide encryption keys in
   /// SQLCipher implementations.
   /// {@endtemplate}
@@ -38,13 +38,13 @@ class NativeDatabase extends DelegatedDatabase {
 
   /// Creates an in-memory database won't persist its changes on disk.
   ///
-  /// {@macro moor_vm_database_factory}
+  /// {@macro drift_vm_database_factory}
   factory NativeDatabase.memory(
       {bool logStatements = false, DatabaseSetup? setup}) {
     return NativeDatabase._(_VmDelegate(null, setup), logStatements);
   }
 
-  /// Creates a moor executor for an opened [database] from the `sqlite3`
+  /// Creates a drift executor for an opened [database] from the `sqlite3`
   /// package.
   ///
   /// When the [closeUnderlyingOnClose] argument is set (which is the default),
@@ -52,10 +52,10 @@ class NativeDatabase extends DelegatedDatabase {
   /// [Database.dispose] the [database] passed to this constructor.
   ///
   /// Using [NativeDatabase.opened] may be useful when you want to use the same
-  /// underlying [Database] in multiple moor connections. Moor uses this
+  /// underlying [Database] in multiple drift connections. Drift uses this
-  /// internally when running [integration tests for migrations](https://moor.simonbinder.eu/docs/advanced-features/migrations/#verifying-migrations).
+  /// internally when running [integration tests for migrations](https://drift.simonbinder.eu/docs/advanced-features/migrations/#verifying-migrations).
   ///
-  /// {@macro moor_vm_database_factory}
+  /// {@macro drift_vm_database_factory}
   factory NativeDatabase.opened(Database database,
       {bool logStatements = false,
       DatabaseSetup? setup,
@@ -81,7 +81,7 @@ class NativeDatabase extends DelegatedDatabase {
   /// it's not necessary to call [closeExistingInstances]. However, features
   /// like hot (stateless) restart can make it impossible to reliably close
   /// every database. In that case, we leak native sqlite3 database connections
-  /// that aren't referenced by any Dart object. Moor can track those
+  /// that aren't referenced by any Dart object. Drift can track those
   /// connections across Dart VM restarts by storing them in an in-memory sqlite
   /// database.
   /// Calling this method can cleanup resources and database locks after a
@@ -94,7 +94,7 @@ class NativeDatabase extends DelegatedDatabase {
   /// aren't any active [NativeDatabase]s, not even on another isolate.
   ///
   /// A suitable place to call [closeExistingInstances] is at an early stage
-  /// of your `main` method, before you're using moor.
+  /// of your `main` method, before you're using drift.
   ///
   /// ```dart
   /// void main() {
@@ -174,7 +174,7 @@ class _VmDelegate extends DatabaseDelegate {
   }
 
   void _initializeDatabase() {
-    _db.useMoorVersions();
+    _db.useNativeFunctions();
     setup?.call(_db);
     versionDelegate = _VmVersionDelegate(_db);
   }

drift/lib/src/ffi/database_tracker.dart

@@ -19,7 +19,7 @@ import 'package:sqlite3/sqlite3.dart';
 /// `VmDatabase.closeExistingInstances()` to release those resources.
 final DatabaseTracker tracker = DatabaseTracker();
 
-/// Internal class that we don't export to moor users. See [tracker] for why
+/// Internal class that we don't export to drift users. See [tracker] for why
 /// this is necessary.
 class DatabaseTracker {
   final Database _db;
@@ -27,7 +27,7 @@ class DatabaseTracker {
   /// Creates a new tracker with necessary tables.
   DatabaseTracker()
       : _db = sqlite3.open(
-          'file:moor_connection_store?mode=memory&cache=shared',
+          'file:drift_connection_store?mode=memory&cache=shared',
           uri: true,
         ) {
     _db.execute('''

drift/lib/src/ffi/native_functions.dart

@@ -5,9 +5,9 @@ import 'package:sqlite3/sqlite3.dart';
 // ignore_for_file: avoid_returning_null, only_throw_errors
 
 /// Extension to register moor-specific sql functions.
-extension EnableMoorFunctions on Database {
+extension EnableNativeFunctions on Database {
   /// Enables moor-specific sql functions on this database.
-  void useMoorVersions() {
+  void useNativeFunctions() {
     createFunction(
       functionName: 'power',
       deterministic: true,

drift/lib/src/isolate.dart

@@ -11,7 +11,7 @@ import '../remote.dart';
 // ignore_for_file: public_member_api_docs
 
 @internal
-class RunningMoorServer {
+class RunningDriftServer {
   final Isolate self;
   final bool killIsolateWhenDone;
 
@@ -21,7 +21,7 @@ class RunningMoorServer {
 
   SendPort get portToOpenConnection => connectPort.sendPort;
 
-  RunningMoorServer(this.self, DatabaseConnection connection,
+  RunningDriftServer(this.self, DatabaseConnection connection,
       {this.killIsolateWhenDone = true})
       : server = DriftServer(connection, allowRemoteShutdown: true) {
     final subscription = connectPort.listen((message) {

drift/lib/src/remote/client_impl.dart

@@ -10,9 +10,9 @@ import '../runtime/cancellation_zone.dart';
 import 'communication.dart';
 import 'protocol.dart';
 
-/// The client part of a remote moor communication scheme.
+/// The client part of a remote drift communication scheme.
-class MoorClient {
+class DriftClient {
-  final MoorCommunication _channel;
+  final DriftCommunication _channel;
 
   late final _RemoteStreamQueryStore _streamStore =
       _RemoteStreamQueryStore(this);
@@ -28,8 +28,8 @@ class MoorClient {
   late QueryExecutorUser _connectedDb;
 
   /// Starts relaying database operations over the request channel.
-  MoorClient(StreamChannel<Object?> channel, bool debugLog)
+  DriftClient(StreamChannel<Object?> channel, bool debugLog)
-      : _channel = MoorCommunication(channel, debugLog) {
+      : _channel = DriftCommunication(channel, debugLog) {
     _channel.setRequestHandler(_handleRequest);
   }
 
@@ -46,7 +46,7 @@ class MoorClient {
 }
 
 abstract class _BaseExecutor extends QueryExecutor {
-  final MoorClient client;
+  final DriftClient client;
   int? _executorId;
 
   _BaseExecutor(this.client, [this._executorId]);
@@ -110,7 +110,7 @@ abstract class _BaseExecutor extends QueryExecutor {
 }
 
 class _RemoteQueryExecutor extends _BaseExecutor {
-  _RemoteQueryExecutor(MoorClient client, [int? executorId])
+  _RemoteQueryExecutor(DriftClient client, [int? executorId])
       : super(client, executorId);
 
   Completer<void>? _setSchemaVersion;
@@ -147,7 +147,7 @@ class _RemoteTransactionExecutor extends _BaseExecutor
     implements TransactionExecutor {
   final int? _outerExecutorId;
 
-  _RemoteTransactionExecutor(MoorClient client, this._outerExecutorId)
+  _RemoteTransactionExecutor(DriftClient client, this._outerExecutorId)
       : super(client);
 
   Completer<bool>? _pendingOpen;
@@ -200,7 +200,7 @@ class _RemoteTransactionExecutor extends _BaseExecutor
 }
 
 class _RemoteStreamQueryStore extends StreamQueryStore {
-  final MoorClient _client;
+  final DriftClient _client;
   final Set<Completer> _awaitingUpdates = {};
 
   _RemoteStreamQueryStore(this._client);

drift/lib/src/remote/communication.dart

@@ -8,15 +8,15 @@ import 'protocol.dart';
 
 /// Wrapper around a two-way communication channel to support requests and
 /// responses.
-class MoorCommunication {
+class DriftCommunication {
-  static const _protocol = MoorProtocol();
+  static const _protocol = DriftProtocol();
 
   final StreamChannel<Object?> _channel;
   final bool _debugLog;
 
   StreamSubscription? _inputSubscription;
 
-  // note that there are two MoorCommunication instances in each connection,
+  // note that there are two DriftCommunication instances in each connection,
   // (one per remote). Each of them has an independent _currentRequestId field
   int _currentRequestId = 0;
   final Completer<void> _closeCompleter = Completer();
@@ -24,8 +24,8 @@ class MoorCommunication {
   final StreamController<Request> _incomingRequests =
       StreamController(sync: true);
 
-  /// Starts a moor communication channel over a raw [StreamChannel].
+  /// Starts a drift communication channel over a raw [StreamChannel].
-  MoorCommunication(this._channel, [this._debugLog = false]) {
+  DriftCommunication(this._channel, [this._debugLog = false]) {
     _inputSubscription = _channel.stream.listen(
       _handleMessage,
       onDone: _closeCompleter.complete,

drift/lib/src/remote/protocol.dart

@@ -1,10 +1,10 @@
-// This is a moor-internal file
+// This is a drift-internal file
 // ignore_for_file: constant_identifier_names, public_member_api_docs
 
 import 'package:drift/drift.dart';
 
-class MoorProtocol {
+class DriftProtocol {
-  const MoorProtocol();
+  const DriftProtocol();
 
   static const _tag_Request = 0;
   static const _tag_Response_success = 1;

drift/lib/src/remote/server_impl.dart

@@ -8,7 +8,7 @@ import '../runtime/cancellation_zone.dart';
 import 'communication.dart';
 import 'protocol.dart';
 
-/// The implementation of a moor server, manging remote channels to send
+/// The implementation of a drift server, manging remote channels to send
 /// database requests.
 class ServerImplementation implements DriftServer {
   /// The Underlying database connection that will be used.
@@ -36,7 +36,7 @@ class ServerImplementation implements DriftServer {
   late final _ServerDbUser _dbUser = _ServerDbUser(this);
 
   bool _isShuttingDown = false;
-  final Set<MoorCommunication> _activeChannels = {};
+  final Set<DriftCommunication> _activeChannels = {};
   final Completer<void> _done = Completer();
 
   /// Creates a server from the underlying connection and further options.
@@ -51,7 +51,7 @@ class ServerImplementation implements DriftServer {
       throw StateError('Cannot add new channels after shutdown() was called');
     }
 
-    final comm = MoorCommunication(channel)..setRequestHandler(_handleRequest);
+    final comm = DriftCommunication(channel)..setRequestHandler(_handleRequest);
     _activeChannels.add(comm);
     comm.closed.then((_) => _activeChannels.remove(comm));
   }
@@ -66,7 +66,7 @@ class ServerImplementation implements DriftServer {
     return done;
   }
 
-  MoorCommunication? get _anyClient {
+  DriftCommunication? get _anyClient {
     final iterator = _activeChannels.iterator;
     if (iterator.moveNext()) {
       return iterator.current;

drift/lib/src/runtime/api/batch.dart

@@ -77,8 +77,8 @@ class Batch {
   /// Writes all present columns from the [row] into all rows in the [table]
   /// that match the [where] clause.
   ///
-  /// For more details on how updates work in moor, check out
+  /// For more details on how updates work in drift, check out
-  /// [UpdateStatement.write] or the [documentation with examples](https://moor.simonbinder.eu/docs/getting-started/writing_queries/#updates-and-deletes)
+  /// [UpdateStatement.write] or the [documentation with examples](https://drift.simonbinder.eu/docs/getting-started/writing_queries/#updates-and-deletes)
   void update<T extends Table, D>(TableInfo<T, D> table, Insertable<D> row,
       {Expression<bool?> Function(T table)? where}) {
     _addUpdate(table, UpdateKind.update);

drift/lib/src/runtime/api/connection.dart

@@ -1,6 +1,6 @@
 part of 'runtime_api.dart';
 
-/// A database connection managed by moor. Contains three components:
+/// A database connection managed by drift. Contains three components:
 /// - a [SqlTypeSystem], which is responsible to map between Dart types and
 ///   values understood by the database engine.
 /// - a [QueryExecutor], which runs sql commands
@@ -32,14 +32,14 @@ class DatabaseConnection {
   ///
   /// This can be useful in scenarios where you need to obtain a database
   /// instance synchronously, but need an async setup. A prime example here is
-  /// `MoorIsolate`:
+  /// `DriftIsolate`:
   ///
   /// ```dart
-  /// @UseMoor(...)
+  /// @DriftDatabase(...)
   /// class MyDatabase extends _$MyDatabase {
   ///   MyDatabase._connect(DatabaseConnection c): super.connect(c);
   ///
-  ///   factory MyDatabase.fromIsolate(MoorIsolate isolate) {
+  ///   factory MyDatabase.fromIsolate(DriftDatabase isolate) {
   ///     return MyDatabase._connect(
   ///       // isolate.connect() returns a future, but we can still return a
   ///       // database synchronously thanks to DatabaseConnection.delayed!

drift/lib/src/runtime/api/connection_user.dart

@@ -77,9 +77,9 @@ abstract class DatabaseConnectionUser {
 
   /// A, potentially more specific, database engine based on the [Zone] context.
   ///
-  /// Inside a [transaction] block, moor will replace this [resolvedEngine] with
+  /// Inside a [transaction] block, drift will replace this [resolvedEngine]
-  /// an engine specific to the transaction. All other methods on this class
+  /// with an engine specific to the transaction. All other methods on this
-  /// implicitly use the [resolvedEngine] to run their SQL statements.
+  /// class implicitly use the [resolvedEngine] to run their SQL statements.
   /// This let's users call methods on their top-level database or dao class
   /// but run them in a transaction-specific executor.
   @internal
@@ -92,8 +92,8 @@ abstract class DatabaseConnectionUser {
   /// In response to calling this method, all streams listening on any of the
   /// [tables] will load their data again.
   ///
-  /// Primarily, this method is meant to be used by moor-internal code. Higher-
+  /// Primarily, this method is meant to be used by drift-internal code. Higher-
-  /// level moor APIs will call this method to dispatch stream updates.
+  /// level drift APIs will call this method to dispatch stream updates.
   /// Of course, you can also call it yourself to manually dispatch table
   /// updates. To obtain a [TableInfo], use the corresponding getter on the
   /// database class.
@@ -106,7 +106,7 @@ abstract class DatabaseConnectionUser {
   /// Dispatches the set of [updates] to the stream query manager.
   ///
   /// This method is more specific than [markTablesUpdated] in the presence of
-  /// triggers or foreign key constraints. Moor needs to support both when
+  /// triggers or foreign key constraints. Drift needs to support both when
   /// calculating which streams to update. For instance, consider a simple
   /// database with two tables (`a` and `b`) and a trigger inserting into `b`
   /// after a delete on `a`).
@@ -149,7 +149,7 @@ abstract class DatabaseConnectionUser {
   /// already ready.
   ///
   /// Calling this method directly might circumvent the current transaction. For
-  /// that reason, it should only be called inside moor.
+  /// that reason, it should only be called inside drift.
   Future<T> doWhenOpened<T>(FutureOr<T> Function(QueryExecutor e) fn) {
     return executor.ensureOpen(attachedDatabase).then((_) => fn(executor));
   }
@@ -169,7 +169,7 @@ abstract class DatabaseConnectionUser {
 
   /// Starts a query on the given table.
   ///
-  /// In moor, queries are commonly used as a builder by chaining calls on them
+  /// In drift, queries are commonly used as a builder by chaining calls on them
   /// using the `..` syntax from Dart. For instance, to load the 10 oldest users
   /// with an 'S' in their name, you could use:
   /// ```dart
@@ -190,7 +190,7 @@ abstract class DatabaseConnectionUser {
   /// duplicate rows from the result set.
   ///
   /// For more information on queries, see the
-  /// [documentation](https://moor.simonbinder.eu/docs/getting-started/writing_queries/).
+  /// [documentation](https://drift.simonbinder.eu/docs/getting-started/writing_queries/).
   SimpleSelectStatement<T, R> select<T extends HasResultSet, R>(
       ResultSetImplementation<T, R> table,
       {bool distinct = false}) {
@@ -226,8 +226,8 @@ abstract class DatabaseConnectionUser {
   /// For simple queries, use [select].
   ///
   /// See also:
-  ///  - the documentation on [aggregate expressions](https://moor.simonbinder.eu/docs/getting-started/expressions/#aggregate)
+  ///  - the documentation on [aggregate expressions](https://drift.simonbinder.eu/docs/getting-started/expressions/#aggregate)
-  ///  - the documentation on [group by](https://moor.simonbinder.eu/docs/advanced-features/joins/#group-by)
+  ///  - the documentation on [group by](https://drift.simonbinder.eu/docs/advanced-features/joins/#group-by)
   JoinedSelectStatement<T, R> selectOnly<T extends HasResultSet, R>(
     ResultSetImplementation<T, R> table, {
     bool distinct = false,
@@ -238,7 +238,7 @@ abstract class DatabaseConnectionUser {
 
   /// Starts a [DeleteStatement] that can be used to delete rows from a table.
   ///
-  /// See the [documentation](https://moor.simonbinder.eu/docs/getting-started/writing_queries/#updates-and-deletes)
+  /// See the [documentation](https://drift.simonbinder.eu/docs/getting-started/writing_queries/#updates-and-deletes)
   /// for more details and example on how delete statements work.
   DeleteStatement<T, D> delete<T extends Table, D>(TableInfo<T, D> table) {
     return DeleteStatement<T, D>(resolvedEngine, table);
@@ -246,7 +246,7 @@ abstract class DatabaseConnectionUser {
 
   /// Executes a custom delete or update statement and returns the amount of
   /// rows that have been changed.
-  /// You can use the [updates] parameter so that moor knows which tables are
+  /// You can use the [updates] parameter so that drift knows which tables are
   /// affected by your query. All select streams that depend on a table
   /// specified there will then update their data. For more accurate results,
   /// you can also set the [updateKind] parameter to [UpdateKind.delete] or
@@ -271,7 +271,7 @@ abstract class DatabaseConnectionUser {
 
   /// Executes a custom insert statement and returns the last inserted rowid.
   ///
-  /// You can tell moor which tables your query is going to affect by using the
+  /// You can tell drift which tables your query is going to affect by using the
   /// [updates] parameter. Query-streams running on any of these tables will
   /// then be re-run.
   Future<int> customInsert(String query,
@@ -289,7 +289,7 @@ abstract class DatabaseConnectionUser {
 
   /// Runs a `INSERT`, `UPDATE` or `DELETE` statement returning rows.
   ///
-  /// You can use the [updates] parameter so that moor knows which tables are
+  /// You can use the [updates] parameter so that drift knows which tables are
   /// affected by your query. All select streams that depend on a table
   /// specified there will then update their data. For more accurate results,
   /// you can also set the [updateKind] parameter.
@@ -399,7 +399,7 @@ abstract class DatabaseConnectionUser {
   /// transaction inside a transaction returns the parent transaction.
   ///
   /// See also:
-  ///  - the docs on [transactions](https://moor.simonbinder.eu/docs/transactions/)
+  ///  - the docs on [transactions](https://drift.simonbinder.eu/docs/transactions/)
   Future<T> transaction<T>(Future<T> Function() action) async {
     final resolved = resolvedEngine;
     if (resolved is Transaction) {

drift/lib/src/runtime/api/dao_base.dart

@@ -13,12 +13,12 @@ abstract class DatabaseAccessor<T extends GeneratedDatabase>
   @override
   final T attachedDatabase;
 
-  /// Used internally by moor
+  /// Used internally by drift
   DatabaseAccessor(this.attachedDatabase) : super.delegate(attachedDatabase);
 }
 
 /// Extension for generated dao classes to keep the old [db] field that was
-/// renamed to [DatabaseAccessor.attachedDatabase] in moor 3.0
+/// renamed to [DatabaseAccessor.attachedDatabase] in drift 3.0
 extension OldDbFieldInDatabaseAccessor<T extends GeneratedDatabase>
     on DatabaseAccessor<T> {
   /// The generated database that this dao is attached to.

drift/lib/src/runtime/api/db_base.dart

@@ -2,7 +2,7 @@ part of 'runtime_api.dart';
 
 /// Keep track of how many databases have been opened for a given database
 /// type.
-/// We get a number of error reports of "moor not generating tables" that have
+/// We get a number of error reports of "drift not generating tables" that have
 /// their origin in users opening multiple instances of their database. This
 /// can cause a race conditions when the second [GeneratedDatabase] is opening a
 /// underlying [DatabaseConnection] that is already opened but doesn't have the
@@ -32,7 +32,7 @@ abstract class GeneratedDatabase extends DatabaseConnectionUser
   /// The collection of update rules contains information on how updates on
   /// tables result in other updates, for instance due to a trigger.
   ///
-  /// There should be no need to overwrite this field, moor will generate an
+  /// There should be no need to overwrite this field, drift will generate an
   /// appropriate implementation automatically.
   StreamQueryUpdateRules get streamUpdateRules =>
       const StreamQueryUpdateRules.none();
@@ -76,13 +76,13 @@ abstract class GeneratedDatabase extends DatabaseConnectionUser
         _openedDbCount[runtimeType] = _openedDbCount[runtimeType]! + 1;
     if (count > 1) {
       driftRuntimeOptions.debugPrint(
-        'WARNING (moor): It looks like you\'ve created the database class '
+        'WARNING (drift): It looks like you\'ve created the database class '
         '$runtimeType multiple times. When these two databases use the same '
         'QueryExecutor, race conditions will occur and might corrupt the '
         'database. \n'
-        'Try to follow the advice at https://moor.simonbinder.eu/faq/#using-the-database '
+        'Try to follow the advice at https://drift.simonbinder.eu/faq/#using-the-database '
         'or, if you know what you\'re doing, set '
-        'moorRuntimeOptions.dontWarnAboutMultipleDatabases = true\n'
+        'driftRuntimeOptions.dontWarnAboutMultipleDatabases = true\n'
         'Here is the stacktrace from when the database was opened a second '
         'time:\n${StackTrace.current}\n'
         'This warning will only appear on debug builds.',
@@ -95,7 +95,7 @@ abstract class GeneratedDatabase extends DatabaseConnectionUser
   /// Creates a [Migrator] with the provided query executor. Migrators generate
   /// sql statements to create or drop tables.
   ///
-  /// This api is mainly used internally in moor, especially to implement the
+  /// This api is mainly used internally in drift, especially to implement the
   /// [beforeOpen] callback from the database site.
   /// However, it can also be used if you need to create tables manually and
   /// outside of a [MigrationStrategy]. For almost all use cases, overriding

drift/lib/src/runtime/api/runtime_api.dart

@@ -13,7 +13,7 @@ part 'dao_base.dart';
 part 'db_base.dart';
 part 'stream_updates.dart';
 
-/// Defines additional runtime behavior for moor. Changing the fields of this
+/// Defines additional runtime behavior for drift. Changing the fields of this
 /// class is rarely necessary.
 class DriftRuntimeOptions {
   /// Don't warn when a database class isn't used as singleton.
@@ -22,7 +22,7 @@ class DriftRuntimeOptions {
   /// The [ValueSerializer] that will be used by default in [DataClass.toJson].
   ValueSerializer defaultSerializer = const ValueSerializer.defaults();
 
-  /// The function used by moor to emit debug prints.
+  /// The function used by drift to emit debug prints.
   ///
   /// This is the function used with `logStatements: true` on databases and
   /// `debugLog` on isolates.

drift/lib/src/runtime/api/stream_updates.dart

@@ -50,7 +50,7 @@ abstract class UpdateRule {
 ///
 /// An update on [on] implicitly triggers updates on [result].
 ///
-/// This class is for use by generated or moor-internal code only. It does not
+/// This class is for use by generated or drift-internal code only. It does not
 /// adhere to Semantic Versioning and should not be used manually.
 class WritePropagation extends UpdateRule {
   /// The updates that cause further writes in [result].

drift/lib/src/runtime/cancellation_zone.dart

@@ -2,7 +2,7 @@ import 'dart:async';
 
 import 'package:meta/meta.dart';
 
-const _key = #moor.runtime.cancellation;
+const _key = #drift.runtime.cancellation;
 
 /// Runs an asynchronous operation with support for cancellations.
 ///

drift/lib/src/runtime/data_class.dart

@@ -22,7 +22,7 @@ abstract class Insertable<D> {
   Map<String, Expression> toColumns(bool nullToAbsent);
 }
 
-/// A common supertype for all data classes generated by moor. Data classes are
+/// A common supertype for all data classes generated by drift. Data classes are
 /// immutable structures that represent a single row in a database table.
 abstract class DataClass {
   /// Constant constructor so that generated data classes can be constant.
@@ -123,8 +123,8 @@ class RawValuesInsertable<D> implements Insertable<D> {
 /// As you can see, a simple `int?` does not provide enough information to
 /// distinguish between the three cases. A `null` value could mean that the
 /// column is absent, or that it should explicitly be set to `null`.
-/// For this reason, moor introduces the [Value] wrapper to make the distinction
+/// For this reason, drift introduces the [Value] wrapper to make the
-/// explicit.
+/// distinction explicit.
 class Value<T> {
   /// Whether this [Value] wrapper contains a present [value] that should be
   /// inserted or updated.
@@ -186,7 +186,7 @@ abstract class ValueSerializer {
   /// This serializer won't transform numbers or strings. Date times will be
   /// encoded as a unix-timestamp.
   ///
-  /// To override the default serializer moor uses, you can change the
+  /// To override the default serializer drift uses, you can change the
   /// [DriftRuntimeOptions.defaultSerializer] field.
   const factory ValueSerializer.defaults() = _DefaultValueSerializer;
 

drift/lib/src/runtime/data_verification.dart

@@ -6,7 +6,7 @@ class VerificationMeta {
   /// The dart getter name of the property being validated.
   final String dartGetterName;
 
-  /// Used internally by moor
+  /// Used internally by drift
   const VerificationMeta(this.dartGetterName);
 }
 
@@ -20,23 +20,23 @@ class VerificationResult {
   /// wrong.
   final String? message;
 
-  /// Used internally by moor
+  /// Used internally by drift
   const VerificationResult(this.success, this.message);
 
-  /// Used internally by moor
+  /// Used internally by drift
   const VerificationResult.success()
       : success = true,
         message = null;
 
-  /// Used internally by moor
+  /// Used internally by drift
   const VerificationResult.failure(this.message) : success = false;
 }
 
-/// Used internally by moor for integrity checks.
+/// Used internally by drift for integrity checks.
 class VerificationContext {
   final Map<VerificationMeta, VerificationResult> _errors;
 
-  /// Used internally by moor
+  /// Used internally by drift
   bool get dataValid => _errors.isEmpty;
 
   /// Creates a verification context, which stores the individual integrity
@@ -44,23 +44,23 @@ class VerificationContext {
   VerificationContext() : _errors = {};
 
   /// Constructs a verification context that can't be used to report errors.
-  /// This is used internally by moor if integrity checks have been disabled.
+  /// This is used internally by drift if integrity checks have been disabled.
   const VerificationContext.notEnabled() : _errors = const {};
 
-  /// Used internally by moor when inserting
+  /// Used internally by drift when inserting
   void handle(VerificationMeta meta, VerificationResult result) {
     if (!result.success) {
       _errors[meta] = result;
     }
   }
 
-  /// Used internally by moor
+  /// Used internally by drift
   void missing(VerificationMeta meta) {
     _errors[meta] = const VerificationResult.failure(
         "This value was required, but isn't present");
   }
 
-  /// Used internally by moor
+  /// Used internally by drift
   void throwIfInvalid(dynamic dataObject) {
     if (dataValid) return;
 

drift/lib/src/runtime/exceptions.dart

@@ -18,19 +18,19 @@ class InvalidDataException implements Exception {
 }
 
 /// A wrapper class for internal exceptions thrown by the underlying database
-/// engine when moor can give additional context or help.
+/// engine when drift can give additional context or help.
 ///
 /// For instance, when we know that an invalid statement has been constructed,
 /// we catch the database exception and try to explain why that has happened.
 class DriftWrappedException implements Exception {
   /// Contains a possible description of why the underlying [cause] occurred,
-  /// for instance because a moor api was misused.
+  /// for instance because a drift api was misused.
   final String message;
 
-  /// The underlying exception caught by moor
+  /// The underlying exception caught by drift
   final Object? cause;
 
-  /// The original stacktrace when caught by moor
+  /// The original stacktrace when caught by drift
   final StackTrace? trace;
 
   /// Creates a new [DriftWrappedException] to provide additional details about
@@ -40,15 +40,15 @@ class DriftWrappedException implements Exception {
   @override
   String toString() {
     return '$cause at \n$trace\n'
-        'Moor detected a possible cause for this: $message';
+        'Drift detected a possible cause for this: $message';
   }
 }
 
-/// Exception thrown by moor when rolling back a transaction fails.
+/// Exception thrown by drift when rolling back a transaction fails.
 ///
 /// When using a `transaction` block, transactions are automatically rolled back
 /// when the inner block throws an exception.
-/// If sending the `ROLLBACK TRANSACTION` command fails as well, moor reports
+/// If sending the `ROLLBACK TRANSACTION` command fails as well, drift reports
 /// both that and the initial error with a [CouldNotRollBackException].
 class CouldNotRollBackException implements Exception {
   /// The original exception that caused the transaction to be rolled back.

drift/lib/src/runtime/executor/connection_pool.dart

@@ -1,7 +1,7 @@
 import 'package:drift/backends.dart';
 import 'package:drift/drift.dart';
 
-/// A query executor for moor that delegates work to multiple executors.
+/// A query executor for drift that delegates work to multiple executors.
 abstract class MultiExecutor extends QueryExecutor {
   /// Creates a query executor that will delegate work to different executors.
   ///

drift/lib/src/runtime/executor/delayed_stream_queries.dart

@@ -5,7 +5,7 @@ import 'stream_queries.dart';
 
 /// Version of [StreamQueryStore] that delegates work to an asynchronously-
 /// available delegate.
-/// This class is internal and should not be exposed to moor users. It's used
+/// This class is internal and should not be exposed to drift users. It's used
 /// through a delayed database connection.
 @internal
 class DelayedStreamQueryStore implements StreamQueryStore {

drift/lib/src/runtime/executor/executor.dart

@@ -7,11 +7,11 @@ import 'package:drift/drift.dart' show OpeningDetails;
 /// A query executor is responsible for executing statements on a database and
 /// return their results in a raw form.
 ///
-/// This is an internal api of moor, which can break often. If you want to
+/// This is an internal api of drift, which can break often. If you want to
 /// implement custom database backends, consider using the new `backends` API.
-/// The [moor_flutter implementation](https://github.com/simolus3/moor/blob/develop/moor_flutter/lib/moor_flutter.dart)
+/// The [NativeDatabase implementation](https://github.com/simolus3/moor/blob/develop/drift/lib/src/ffi/database.dart)
 /// might be useful as a reference. If you want to write your own database
-/// engine to use with moor and run into issues, please consider creating an
+/// engine to use with drift and run into issues, please consider creating an
 /// issue.
 abstract class QueryExecutor {
   /// The [SqlDialect] to use for this database engine.
@@ -42,8 +42,8 @@ abstract class QueryExecutor {
 
   /// Prepares and runs [statements].
   ///
-  /// Running them doesn't need to happen in a transaction. When using moor's
+  /// Running them doesn't need to happen in a transaction. When using drift's
-  /// batch api, moor will call this method from a transaction either way. This
+  /// batch api, drift will call this method from a transaction either way. This
   /// method mainly exists to save duplicate parsing costs, allowing each
   /// statement to be prepared only once.
   Future<void> runBatched(BatchedStatements statements);
@@ -120,7 +120,7 @@ class ArgumentsForBatchedStatement {
   /// Bound arguments for the referenced statement.
   final List<Object?> arguments;
 
-  /// Used internally by moor.
+  /// Used internally by drift.
   ArgumentsForBatchedStatement(this.statementIndex, this.arguments);
 
   @override

drift/lib/src/runtime/executor/helpers/delegates.dart

@@ -28,7 +28,7 @@ abstract class DatabaseDelegate extends QueryDelegate {
   /// MySql server we connect to)
   /// - [OnOpenVersionDelegate] for databases whose schema version can only be
   /// set while opening it (such as sqflite)
-  /// - [DynamicVersionDelegate] for databases where moor can set the schema
+  /// - [DynamicVersionDelegate] for databases where drift can set the schema
   /// version at any time (used for the web and VM implementation)
   DbVersionDelegate get versionDelegate;
 
@@ -37,17 +37,17 @@ abstract class DatabaseDelegate extends QueryDelegate {
 
   /// A future that completes with `true` when this database is open and with
   /// `false` when its not. The future may never complete with an error or with
-  /// null. It should return relatively quickly, as moor queries it before each
+  /// null. It should return relatively quickly, as drift queries it before each
   /// statement it sends to the database.
   FutureOr<bool> get isOpen;
 
-  /// Opens the database. Moor will only call this when [isOpen] has returned
+  /// Opens the database. Drift will only call this when [isOpen] has returned
-  /// false before. Further, moor will not attempt to open a database multiple
+  /// false before. Further, drift will not attempt to open a database multiple
   /// times, so you don't have to worry about a connection being created
   /// multiple times.
   ///
   /// The [QueryExecutorUser] is the user-defined database annotated with
-  /// [UseMoor]. It might be useful to read the
+  /// [DriftDatabase]. It might be useful to read the
   /// [QueryExecutorUser.schemaVersion] if that information is required while
   /// opening the database.
   Future<void> open(QueryExecutorUser db);
@@ -58,7 +58,7 @@ abstract class DatabaseDelegate extends QueryDelegate {
     // default no-op implementation
   }
 
-  /// Callback from moor after the database has been fully opened and all
+  /// Callback from drift after the database has been fully opened and all
   /// migrations ran.
   void notifyDatabaseOpened(OpeningDetails details) {
     // default no-op
@@ -122,9 +122,9 @@ abstract class TransactionDelegate {
 }
 
 /// A [TransactionDelegate] for database APIs which don't already support
-/// creating transactions. Moor will send a `BEGIN TRANSACTION` statement at the
+/// creating transactions. Drift will send a `BEGIN TRANSACTION` statement at
-/// beginning, then block the database, and finally send a `COMMIT` statement
+/// the beginning, then block the database, and finally send a `COMMIT`
-/// at the end.
+/// statement at the end.
 class NoTransactionDelegate extends TransactionDelegate {
   /// The statement that starts a transaction on this database engine.
   final String start;

drift/lib/src/runtime/executor/helpers/engines.dart

@@ -28,8 +28,8 @@ abstract class _BaseExecutor extends QueryExecutor {
       throw StateError('''
 Tried to run an operation without first calling QueryExecutor.ensureOpen()!
 
-If you're seeing this exception from a moor database, it may indicate a bug in
+If you're seeing this exception from a drift database, it may indicate a bug in
-moor itself. Please consider opening an issue with the stack trace and details
+drift itself. Please consider opening an issue with the stack trace and details
 on how to reproduce this.''');
     }
 
@@ -59,7 +59,7 @@ without awaiting every statement in it.''');
 
   void _log(String sql, List<Object?> args) {
     if (logStatements) {
-      driftRuntimeOptions.debugPrint('Moor: Sent $sql with args $args');
+      driftRuntimeOptions.debugPrint('Drift: Sent $sql with args $args');
     }
   }
 
@@ -117,7 +117,7 @@ without awaiting every statement in it.''');
       assert(_debugCheckIsOpen());
       if (logStatements) {
         driftRuntimeOptions
-            .debugPrint('Moor: Executing $statements in a batch');
+            .debugPrint('Drift: Executing $statements in a batch');
       }
       return impl.runBatched(statements);
     });
@@ -352,11 +352,11 @@ class DelegatedDatabase extends _BaseExecutor {
   }
 }
 
-/// Inside a `beforeOpen` callback, all moor apis must be available. At the same
+/// Inside a `beforeOpen` callback, all drift apis must be available. At the
-/// time, the `beforeOpen` callback must complete before any query sent outside
+/// same time, the `beforeOpen` callback must complete before any query sent
-/// of a `beforeOpen` callback can run. We do this by introducing a special
+/// outside of a `beforeOpen` callback can run. We do this by introducing a
-/// executor that delegates all work to the original executor, but without
+/// special executor that delegates all work to the original executor, but
-/// blocking on `ensureOpen`
+/// without blocking on `ensureOpen`
 class _BeforeOpeningExecutor extends _BaseExecutor {
   final DelegatedDatabase _base;
 

drift/lib/src/runtime/executor/stream_queries.dart

@@ -10,7 +10,7 @@ import '../cancellation_zone.dart';
 
 const _listEquality = ListEquality<Object?>();
 
-// This is an internal moor library that's never exported to users.
+// This is an internal drift library that's never exported to users.
 // ignore_for_file: public_member_api_docs
 
 /// Representation of a select statement that knows from which tables the
@@ -132,7 +132,7 @@ class StreamQueryStore {
 
     // Hey there! If you're sent here because your Flutter tests fail, please
     // call and await Database.close() in your Flutter widget tests!
-    // Moor uses timers internally so that after you stopped listening to a
+    // Drift uses timers internally so that after you stopped listening to a
     // stream, it can keep its cache just a bit longer. When you listen to
     // streams a lot, this helps reduce duplicate statements, especially with
     // Flutter's StreamBuilder.

drift/lib/src/runtime/executor/transactions.dart

@@ -86,7 +86,7 @@ class _TransactionStreamStore extends StreamQueryStore {
 
 /// Special query engine to run the [MigrationStrategy.beforeOpen] callback.
 ///
-/// To use this api, moor users should use the [MigrationStrategy.beforeOpen]
+/// To use this api, drift users should use the [MigrationStrategy.beforeOpen]
 /// parameter inside the [GeneratedDatabase.migration] getter.
 @internal
 class BeforeOpenRunner extends DatabaseConnectionUser {

drift/lib/src/runtime/query_builder/components/join.dart

@@ -18,7 +18,7 @@ const Map<_JoinType, String> _joinKeywords = {
   _JoinType.cross: 'CROSS',
 };
 
-/// Used internally by moor when calling [SimpleSelectStatement.join].
+/// Used internally by drift when calling [SimpleSelectStatement.join].
 ///
 /// You should use [innerJoin], [leftOuterJoin] or [crossJoin] to obtain a
 /// [Join] instance.
@@ -61,14 +61,14 @@ class Join<T extends HasResultSet, D> extends Component {
 
 /// Creates a sql inner join that can be used in [SimpleSelectStatement.join].
 ///
-/// {@template moor_join_include_results}
+/// {@template drift_join_include_results}
 /// The optional [useColumns] parameter (defaults to true) can be used to
 /// exclude the [other] table from the result set. When set to false,
 /// [TypedResult.readTable] will return `null` for that table.
 /// {@endtemplate}
 ///
 /// See also:
-///  - https://moor.simonbinder.eu/docs/advanced-features/joins/#joins
+///  - https://drift.simonbinder.eu/docs/advanced-features/joins/#joins
 ///  - http://www.sqlitetutorial.net/sqlite-inner-join/
 Join innerJoin<T extends HasResultSet, D>(
     ResultSetImplementation<T, D> other, Expression<bool?> on,
@@ -79,10 +79,10 @@ Join innerJoin<T extends HasResultSet, D>(
 /// Creates a sql left outer join that can be used in
 /// [SimpleSelectStatement.join].
 ///
-/// {@macro moor_join_include_results}
+/// {@macro drift_join_include_results}
 ///
 /// See also:
-///  - https://moor.simonbinder.eu/docs/advanced-features/joins/#joins
+///  - https://drift.simonbinder.eu/docs/advanced-features/joins/#joins
 ///  - http://www.sqlitetutorial.net/sqlite-left-join/
 Join leftOuterJoin<T extends HasResultSet, D>(
     ResultSetImplementation<T, D> other, Expression<bool?> on,
@@ -93,10 +93,10 @@ Join leftOuterJoin<T extends HasResultSet, D>(
 /// Creates a sql cross join that can be used in
 /// [SimpleSelectStatement.join].
 ///
-/// {@macro moor_join_include_results}
+/// {@macro drift_join_include_results}
 ///
 /// See also:
-///  - https://moor.simonbinder.eu/docs/advanced-features/joins/#joins
+///  - https://drift.simonbinder.eu/docs/advanced-features/joins/#joins
 ///  - http://www.sqlitetutorial.net/sqlite-cross-join/
 Join crossJoin<T extends HasResultSet, D>(ResultSetImplementation<T, D> other,
     {bool? useColumns}) {

drift/lib/src/runtime/query_builder/expressions/aggregate.dart

@@ -3,7 +3,7 @@ part of '../query_builder.dart';
 /// Returns the amount of rows in the current group matching the optional
 /// [filter].
 ///
-/// {@templace moor_aggregate_filter}
+/// {@templace drift_aggregate_filter}
 /// To only consider rows matching a predicate, you can set the optional
 /// [filter]. Note that [filter] is only available from sqlite 3.30, released on
 /// 2019-10-04. Most devices will use an older sqlite version.
@@ -24,7 +24,7 @@ extension BaseAggregate<DT> on Expression<DT> {
   ///
   /// If [distinct] is set (defaults to false), duplicate values will not be
   /// counted twice.
-  /// {@macro moor_aggregate_filter}
+  /// {@macro drift_aggregate_filter}
   Expression<int> count({bool? distinct, Expression<bool?>? filter}) {
     return _AggregateExpression('COUNT', this,
         filter: filter, distinct: distinct);
@@ -53,21 +53,21 @@ extension BaseAggregate<DT> on Expression<DT> {
 extension ArithmeticAggregates<DT extends num> on Expression<DT?> {
   /// Return the average of all non-null values in this group.
   ///
-  /// {@macro moor_aggregate_filter}
+  /// {@macro drift_aggregate_filter}
   Expression<double?> avg({Expression<bool?>? filter}) =>
       _AggregateExpression('AVG', this, filter: filter);
 
   /// Return the maximum of all non-null values in this group.
   ///
   /// If there are no non-null values in the group, returns null.
-  /// {@macro moor_aggregate_filter}
+  /// {@macro drift_aggregate_filter}
   Expression<DT?> max({Expression<bool?>? filter}) =>
       _AggregateExpression('MAX', this, filter: filter);
 
   /// Return the minimum of all non-null values in this group.
   ///
   /// If there are no non-null values in the group, returns null.
-  /// {@macro moor_aggregate_filter}
+  /// {@macro drift_aggregate_filter}
   Expression<DT?> min({Expression<bool?>? filter}) =>
       _AggregateExpression('MIN', this, filter: filter);
 
@@ -79,7 +79,7 @@ extension ArithmeticAggregates<DT extends num> on Expression<DT?> {
   ///
   /// See also [total], which behaves similarly but returns a floating point
   /// value and doesn't throw an overflow exception.
-  /// {@macro moor_aggregate_filter}
+  /// {@macro drift_aggregate_filter}
   Expression<DT?> sum({Expression<bool?>? filter}) =>
       _AggregateExpression('SUM', this, filter: filter);
 
@@ -87,7 +87,7 @@ extension ArithmeticAggregates<DT extends num> on Expression<DT?> {
   ///
   /// If all values in the group are null, [total] returns `0.0`. This function
   /// uses floating-point values internally.
-  /// {@macro moor_aggregate_filter}
+  /// {@macro drift_aggregate_filter}
   Expression<double?> total({Expression<bool?>? filter}) =>
       _AggregateExpression('TOTAL', this, filter: filter);
 }
@@ -95,21 +95,21 @@ extension ArithmeticAggregates<DT extends num> on Expression<DT?> {
 /// Provides aggregate functions that are available on date time expressions.
 extension DateTimeAggregate on Expression<DateTime?> {
   /// Return the average of all non-null values in this group.
-  /// {@macro moor_aggregate_filter}
+  /// {@macro drift_aggregate_filter}
   Expression<DateTime> avg({Expression<bool?>? filter}) =>
       secondsSinceEpoch.avg(filter: filter).roundToInt().dartCast();
 
   /// Return the maximum of all non-null values in this group.
   ///
   /// If there are no non-null values in the group, returns null.
-  /// {@macro moor_aggregate_filter}
+  /// {@macro drift_aggregate_filter}
   Expression<DateTime> max({Expression<bool?>? filter}) =>
       _AggregateExpression('MAX', this, filter: filter);
 
   /// Return the minimum of all non-null values in this group.
   ///
   /// If there are no non-null values in the group, returns null.
-  /// {@macro moor_aggregate_filter}
+  /// {@macro drift_aggregate_filter}
   Expression<DateTime> min({Expression<bool?>? filter}) =>
       _AggregateExpression('MIN', this, filter: filter);
 }

drift/lib/src/runtime/query_builder/expressions/datetimes.dart

@@ -49,7 +49,7 @@ extension DateTimeExpressions on Expression<DateTime?> {
   /// Returns an expression containing the amount of seconds from the unix
   /// epoch (January 1st, 1970) to `this` datetime expression. The datetime is
   /// assumed to be in utc.
-  // for moor, date times are just unix timestamps, so we don't need to rewrite
+  // for drift, date times are just unix timestamps, so we don't need to rewrite
   // anything when converting
   Expression<int> get secondsSinceEpoch => dartCast();
 

drift/lib/src/runtime/query_builder/expressions/expression.dart

@@ -6,7 +6,7 @@ const _equality = ListEquality();
 ///
 /// Most prominently, this includes [Expression]s.
 ///
-/// Used internally by moor.
+/// Used internally by drift.
 abstract class FunctionParameter implements Component {}
 
 /// Any sql expression that evaluates to some generic value. This does not
@@ -44,14 +44,14 @@ abstract class Expression<D> implements FunctionParameter {
   /// will __NOT__ generate a `CAST` expression in sql. To generate a `CAST`
   /// in sql, use [cast].
   ///
-  /// This method is used internally by moor.
+  /// This method is used internally by drift.
   Expression<D2> dartCast<D2>() {
     return _DartCastExpression<D, D2>(this);
   }
 
   /// Generates a `CAST(expression AS TYPE)` expression.
   ///
-  /// Note that this does not do a meaningful conversion for moor-only types
+  /// Note that this does not do a meaningful conversion for drift-only types
   /// like `bool` or `DateTime`. Both would simply generate a `CAST AS INT`
   /// expression.
   Expression<D2> cast<D2>() => _CastInSqlExpression<D, D2>(this);
@@ -406,9 +406,9 @@ class _CastInSqlExpression<D1, D2> extends Expression<D2> {
 
 /// A sql expression that calls a function.
 ///
-/// This class is mainly used by moor internally. If you find yourself using
+/// This class is mainly used by drift internally. If you find yourself using
 /// this class, consider [creating an issue](https://github.com/simolus3/moor/issues/new)
-/// to request native support in moor.
+/// to request native support in drift.
 class FunctionCallExpression<R> extends Expression<R> {
   /// The name of the function to call
   final String functionName;

drift/lib/src/runtime/query_builder/expressions/text.dart

@@ -14,8 +14,9 @@ extension StringExpressionOperators on Expression<String?> {
   /// The [multiLine], [caseSensitive], [unicode] and [dotAll] parameters
   /// correspond to the parameters on [RegExp].
   ///
-  /// Note that this function is only available when using `moor_ffi`. If you
+  /// Note that this function is only available when using a `NativeDatabase`.
-  /// need to support the web or `moor_flutter`, consider using [like] instead.
+  /// If you need to support the web or `moor_flutter`, consider using [like]
+  /// instead.
   Expression<bool?> regexp(
     String regex, {
     bool multiLine = false,
@@ -23,7 +24,7 @@ extension StringExpressionOperators on Expression<String?> {
     bool unicode = false,
     bool dotAll = false,
   }) {
-    // moor_ffi has a special regexp sql function that takes a third parameter
+    // We have a special regexp sql function that takes a third parameter
     // to encode flags. If the least significant bit is set, multiLine is
     // enabled. The next three bits enable case INSENSITIVITY (it's sensitive
     // by default), unicode and dotAll.

drift/lib/src/runtime/query_builder/migration.dart

@@ -10,13 +10,13 @@ typedef OnCreate = Future<void> Function(Migrator m);
 typedef OnUpgrade = Future<void> Function(Migrator m, int from, int to);
 
 /// Signature of a function that's called before a database is marked opened by
-/// moor, but after migrations took place. This is a suitable callback to to
+/// drift, but after migrations took place. This is a suitable callback to to
 /// populate initial data or issue `PRAGMA` statements that you want to use.
 typedef OnBeforeOpen = Future<void> Function(OpeningDetails details);
 
 Future<void> _defaultOnCreate(Migrator m) => m.createAll();
 Future<void> _defaultOnUpdate(Migrator m, int from, int to) async =>
-    throw Exception("You've bumped the schema version for your moor database "
+    throw Exception("You've bumped the schema version for your drift database "
         "but didn't provide a strategy for schema updates. Please do that by "
         'adapting the migrations getter in your database class.');
 
@@ -50,7 +50,7 @@ class MigrationStrategy {
 class Migrator {
   final GeneratedDatabase _db;
 
-  /// Used internally by moor when opening the database.
+  /// Used internally by drift when opening the database.
   Migrator(this._db);
 
   /// Creates all tables specified for the database, if they don't exist
@@ -108,8 +108,8 @@ class Migrator {
   ///
   /// The [migration] to run describes the transformation to apply to the table.
   /// The individual fields of the [TableMigration] class contain more
-  /// information on the transformations supported at the moment. Moor's
+  /// information on the transformations supported at the moment. Drifts's
-  /// [documentation][moor docs] also contains more details and examples for
+  /// [documentation][drift docs] also contains more details and examples for
   /// common migrations that can be run with [alterTable].
   ///
   /// When deleting columns from a table, make sure to migrate tables that have
@@ -119,7 +119,7 @@ class Migrator {
   /// not reliably handle views at the moment.
   ///
   /// [other alter]: https://www.sqlite.org/lang_altertable.html#otheralter
-  /// [moor docs]: https://moor.simonbinder.eu/docs/advanced-features/migrations/#complex-migrations
+  /// [drift docs]: https://drift.simonbinder.eu/docs/advanced-features/migrations/#complex-migrations
   @experimental
   Future<void> alterTable(TableMigration migration) async {
     final foreignKeysEnabled =
@@ -349,14 +349,14 @@ class Migrator {
 
   /// Changes the name of a column in a [table].
   ///
-  /// After renaming a column in a Dart table or a moor file and re-running the
+  /// After renaming a column in a Dart table or a drift file and re-running the
   /// generator, you can use [renameColumn] in a migration step to rename the
   /// column for existing databases.
   ///
   /// The [table] argument must be set to the table enclosing the changed
   /// column. The [oldName] must be set to the old name of the [column] in SQL.
-  /// For Dart tables, note that moor will transform `camelCase` column names in
+  /// For Dart tables, note that drift will transform `camelCase` column names
-  /// Dart to `snake_case` column names in SQL.
+  /// in Dart to `snake_case` column names in SQL.
   ///
   /// __Important compatibility information__: [renameColumn] uses an
   /// `ALTER TABLE RENAME COLUMN` internally. Support for that syntax was added
@@ -378,7 +378,7 @@ class Migrator {
   /// Changes the [table] name from [oldName] to the current
   /// [TableInfo.actualTableName].
   ///
-  /// After renaming a table in moor or Dart and re-running the generator, you
+  /// After renaming a table in drift or Dart and re-running the generator, you
   /// can use [renameTable] in a migration step to rename the table in existing
   /// databases.
   Future<void> renameTable(TableInfo table, String oldName) async {
@@ -415,7 +415,7 @@ class OpeningDetails {
   /// Whether a schema upgrade was performed while opening the database.
   bool get hadUpgrade => !wasCreated && versionBefore != versionNow;
 
-  /// Used internally by moor when opening a database.
+  /// Used internally by drift when opening a database.
   const OpeningDetails(this.versionBefore, this.versionNow)
       // Should use null instead of 0 for consistency
       : assert(versionBefore != 0);
@@ -429,7 +429,7 @@ extension DestructiveMigrationExtension on GeneratedDatabase {
   /// To use this behavior, override the `migration` getter in your database:
   ///
   /// ```dart
-  /// @UseMoor(...)
+  /// @DriftDatabase(...)
   /// class MyDatabase extends _$MyDatabase {
   ///   @override
   ///   MigrationStrategy get migration => destructiveFallback;
@@ -457,7 +457,7 @@ extension DestructiveMigrationExtension on GeneratedDatabase {
 /// Contains instructions needed to run a complex migration on a table, using
 /// the steps described in [Making other kinds of table schema changes][https://www.sqlite.org/lang_altertable.html#otheralter].
 ///
-/// For examples and more details, see [the documentation](https://moor.simonbinder.eu/docs/advanced-features/migrations/#complex-migrations).
+/// For examples and more details, see [the documentation](https://drift.simonbinder.eu/docs/advanced-features/migrations/#complex-migrations).
 @experimental
 class TableMigration {
   /// The table to migrate. It is assumed that this table already exists at the

drift/lib/src/runtime/query_builder/query_builder.dart

@@ -71,7 +71,7 @@ void _writeCommaSeparated(
   }
 }
 
-/// An enumeration of database systems supported by moor. Only
+/// An enumeration of database systems supported by drift. Only
 /// [SqlDialect.sqlite] is officially supported, all others are in an
 /// experimental state at the moment.
 enum SqlDialect {

drift/lib/src/runtime/query_builder/schema/column_impl.dart

@@ -15,15 +15,15 @@ class GeneratedColumn<T> extends Column<T> {
   /// Whether null values are allowed for this column.
   final bool $nullable;
 
-  /// Default constraints generated by moor.
+  /// Default constraints generated by drift.
   final String? _defaultConstraints;
 
   /// Custom constraints that have been specified for this column.
   ///
   /// Some constraints, like `NOT NULL` or checks for booleans, are generated by
-  /// moor by default.
+  /// drift by default.
   /// Constraints can also be overridden with [BuildColumn.customConstraint],
-  /// in which case the moor constraints will not be applied.
+  /// in which case the drift constraints will not be applied.
   final String? $customConstraints;
 
   /// The default expression to be used during inserts when no value has been
@@ -48,7 +48,7 @@ class GeneratedColumn<T> extends Column<T> {
   final bool requiredDuringInsert;
 
   /// Whether this column has an `AUTOINCREMENT` primary key constraint that was
-  /// created by moor.
+  /// created by drift.
   bool get hasAutoIncrement =>
       _defaultConstraints?.contains('AUTOINCREMENT') == true;
 
@@ -111,7 +111,7 @@ class GeneratedColumn<T> extends Column<T> {
         if (writeBrackets) into.buffer.write(')');
       }
 
-      // these custom constraints refer to builtin constraints from moor
+      // these custom constraints refer to builtin constraints from drift
       if (_defaultConstraints != null) {
         into.buffer
           ..write(' ')
@@ -138,12 +138,6 @@ class GeneratedColumn<T> extends Column<T> {
   /// implementation only checks for nullability, but subclasses might enforce
   /// additional checks. For instance, a text column might verify that a text
   /// has a certain length.
-  ///
-  /// Note: The behavior of this method was changed in moor 1.5. Before, null
-  /// values were interpreted as an absent value during updates or if the
-  /// [defaultValue] is set. Verification was skipped for absent values.
-  /// This is no longer the case, all null values are assumed to be an sql
-  /// `NULL`.
   VerificationResult isAcceptableValue(T value, VerificationMeta meta) {
     final nullOk = $nullable;
     if (!nullOk && value == null) {

drift/lib/src/runtime/query_builder/schema/entities.dart

@@ -9,7 +9,7 @@ abstract class DatabaseSchemaEntity {
 
 /// A sqlite trigger that's executed before, after or instead of a subset of
 /// writes on a specific tables.
-/// In moor, triggers can only be declared in `.moor` files.
+/// In drift, triggers can only be declared in `.drift` files.
 ///
 /// For more information on triggers, see the [CREATE TRIGGER][sqlite-docs]
 /// documentation from sqlite, or the [entry on sqlitetutorial.net][sql-tut].
@@ -49,7 +49,7 @@ class Index extends DatabaseSchemaEntity {
 
 /// A sqlite view.
 ///
-/// In moor, views can only be declared in `.moor` files.
+/// In drift, views can only be declared in `.drift` files.
 ///
 /// For more information on views, see the [CREATE VIEW][sqlite-docs]
 /// documentation from sqlite, or the [entry on sqlitetutorial.net][sql-tut].
@@ -72,7 +72,7 @@ abstract class View<Self, Row> extends ResultSetImplementation<Self, Row>
 /// An internal schema entity to run an sql statement when the database is
 /// created.
 ///
-/// The generator uses this entity to implement `@create` statements in moor
+/// The generator uses this entity to implement `@create` statements in drift
 /// files:
 /// ```sql
 /// CREATE TABLE users (name TEXT);
@@ -80,7 +80,7 @@ abstract class View<Self, Row> extends ResultSetImplementation<Self, Row>
 /// @create: INSERT INTO users VALUES ('Bob');
 /// ```
 /// A [OnCreateQuery] is emitted for each `@create` statement in an included
-/// moor file.
+/// drift file.
 class OnCreateQuery extends DatabaseSchemaEntity {
   /// The sql statement that should be run in the default `onCreate` clause.
   final String sql;

drift/lib/src/runtime/query_builder/schema/table_info.dart

@@ -2,12 +2,12 @@ part of '../query_builder.dart';
 
 /// Base class for generated table classes.
 ///
-/// Moor generates a subclass of [TableInfo] for each table used in a database.
+/// Drift generates a subclass of [TableInfo] for each table used in a database.
 /// This classes contains information about the table's schema (e.g. its
 /// [primaryKey] or [$columns]).
 ///
 /// [TableDsl] is the original table class written by the user. For tables
-/// defined in moor files, this is the table implementation class itself.
+/// defined in drift files, this is the table implementation class itself.
 /// [D] is the type of the data class generated from the table.
 ///
 /// To obtain an instance of this class, use a table getter from the database.
@@ -97,7 +97,7 @@ mixin TableInfo<TableDsl extends Table, D> on Table
   int get hashCode => Object.hash(aliasedName, actualTableName);
 }
 
-/// Additional interface for tables in a moor file that have been created with
+/// Additional interface for tables in a drift file that have been created with
 /// an `CREATE VIRTUAL TABLE STATEMENT`.
 mixin VirtualTableInfo<TableDsl extends Table, D> on TableInfo<TableDsl, D> {
   /// Returns the module name and the arguments that were used in the statement
@@ -108,7 +108,7 @@ mixin VirtualTableInfo<TableDsl extends Table, D> on TableInfo<TableDsl, D> {
 
 /// Static extension members for generated table classes.
 ///
-/// Most of these are accessed internally by moor or by generated code.
+/// Most of these are accessed internally by drift or by generated code.
 extension TableInfoUtils<TableDsl, D> on ResultSetImplementation<TableDsl, D> {
   /// Like [map], but from a [row] instead of the low-level map.
   D mapFromRow(QueryRow row, {String? tablePrefix}) {
@@ -131,7 +131,7 @@ extension TableInfoUtils<TableDsl, D> on ResultSetImplementation<TableDsl, D> {
 
   /// Like [mapFromRow], but maps columns from the result through [alias].
   ///
-  /// This is used internally by moor to support mapping to a table from a
+  /// This is used internally by drift to support mapping to a table from a
   /// select statement with different column names. For instance, for:
   ///
   /// ```sql
@@ -140,7 +140,7 @@ extension TableInfoUtils<TableDsl, D> on ResultSetImplementation<TableDsl, D> {
   /// query: SELECT foo AS c1, bar AS c2 FROM tbl;
   /// ```
   ///
-  /// Moor would generate code to call this method with `'c1': 'foo'` and
+  /// Drift would generate code to call this method with `'c1': 'foo'` and
   /// `'c2': 'bar'` in [alias].
   D mapFromRowWithAlias(QueryRow row, Map<String, String> alias) {
     return map({
@@ -158,7 +158,7 @@ extension RowIdExtension on TableInfo {
   /// column is an _alias_ to the row id in sqlite3.
   ///
   /// If the row id has not explicitly been declared as a column aliasing it,
-  /// the [rowId] will not be part of a moor-generated data class. In this
+  /// the [rowId] will not be part of a drift-generated data class. In this
   /// case, the [rowId] getter can be used to refer to a table's row id in a
   /// query.
   Expression<int?> get rowId {

drift/lib/src/runtime/query_builder/statements/insert.dart

@@ -11,7 +11,7 @@ class InsertStatement<T extends Table, D> {
   final TableInfo<T, D> table;
 
   /// Constructs an insert statement from the database and the table. Used
-  /// internally by moor.
+  /// internally by drift.
   InsertStatement(this.database, this.table);
 
   /// Inserts a row constructed from the fields in [entity].
@@ -111,7 +111,7 @@ class InsertStatement<T extends Table, D> {
   /// Creates a [GenerationContext] which contains the sql necessary to run an
   /// insert statement fro the [entry] with the [mode].
   ///
-  /// This method is used internally by moor. Consider using [insert] instead.
+  /// This method is used internally by drift. Consider using [insert] instead.
   GenerationContext createContext(Insertable<D> entry, InsertMode mode,
       {UpsertClause<T, D>? onConflict, bool returning = false}) {
     _validateIntegrity(entry);

drift/lib/src/runtime/query_builder/statements/query.dart

@@ -10,7 +10,7 @@ abstract class Query<T extends HasResultSet, D> extends Component {
   /// The (main) table or view that this query operates on.
   ResultSetImplementation<T, D> table;
 
-  /// Used internally by moor. Users should use the appropriate methods on
+  /// Used internally by drift. Users should use the appropriate methods on
   /// [DatabaseConnectionUser] instead.
   Query(this.database, this.table);
 
@@ -57,9 +57,9 @@ abstract class Query<T extends HasResultSet, D> extends Component {
 
   /// Constructs the query that can then be sent to the database executor.
   ///
-  /// This is used internally by moor to run the query. Users should use the
+  /// This is used internally by drift to run the query. Users should use the
-  /// other methods explained in the [documentation][moor-docs].
+  /// other methods explained in the [documentation][drift-docs].
-  /// [moor-docs]: https://moor.simonbinder.eu/docs/getting-started/writing_queries/
+  /// [drift-docs]: https://drift.simonbinder.eu/docs/getting-started/writing_queries/
   GenerationContext constructQuery() {
     final ctx = GenerationContext.fromDb(database);
     writeInto(ctx);
@@ -73,7 +73,7 @@ abstract class Query<T extends HasResultSet, D> extends Component {
 /// Useful for refining the return type of a query, while still delegating
 /// whether to [get] or [watch] results to the consuming code.
 ///
-/// {@template moor_multi_selectable_example}
+/// {@template drift_multi_selectable_example}
 /// ```dart
 /// /// Retrieve a page of [Todo]s.
 /// MultiSelectable<Todo> pageOfTodos(int page, {int pageSize = 10}) {
@@ -101,7 +101,7 @@ abstract class MultiSelectable<T> {
 /// Useful for refining the return type of a query, while still delegating
 /// whether to [getSingle] or [watchSingle] results to the consuming code.
 ///
-/// {@template moor_single_selectable_example}
+/// {@template drift_single_selectable_example}
 /// ```dart
 /// // Retrieve a todo known to exist.
 /// SingleSelectable<Todo> entryById(int id) {
@@ -120,7 +120,7 @@ abstract class SingleSelectable<T> {
   /// value. the query returns no or too many rows, the returned future will
   /// complete with an error.
   ///
-  /// {@template moor_single_query_expl}
+  /// {@template drift_single_query_expl}
   /// Be aware that this operation won't put a limit clause on this statement,
   /// if that's needed you would have to do use [SimpleSelectStatement.limit]:
   /// ```dart
@@ -147,7 +147,7 @@ abstract class SingleSelectable<T> {
   /// `Stream<T>`. If, at any point, the query emits no or more than one rows,
   /// an error will be added to the stream instead.
   ///
-  /// {@macro moor_single_query_expl}
+  /// {@macro drift_single_query_expl}
   Stream<T> watchSingle();
 }
 
@@ -158,7 +158,7 @@ abstract class SingleSelectable<T> {
 /// whether to [getSingleOrNull] or [watchSingleOrNull] result to the
 /// consuming code.
 ///
-/// {@template moor_single_or_null_selectable_example}
+/// {@template drift_single_or_null_selectable_example}
 ///```dart
 /// // Retrieve a todo from an external link that may not be valid.
 /// SingleOrNullSelectable<Todo> entryFromExternalLink(int id) {
@@ -177,7 +177,7 @@ abstract class SingleOrNullSelectable<T> {
   /// value. If the result too many values, this method will throw. If no
   /// row is returned, `null` will be returned instead.
   ///
-  /// {@macro moor_single_query_expl}
+  /// {@macro drift_single_query_expl}
   ///
   /// See also: [Selectable.getSingle], which can be used if the query will
   /// always evaluate to exactly one row.
@@ -191,7 +191,7 @@ abstract class SingleOrNullSelectable<T> {
   /// If the query emits zero rows at some point, `null` will be added
   /// to the stream instead.
   ///
-  /// {@macro moor_single_query_expl}
+  /// {@macro drift_single_query_expl}
   Stream<T?> watchSingleOrNull();
 }
 
@@ -202,9 +202,9 @@ abstract class SingleOrNullSelectable<T> {
 /// [Stream], you can refine your return type using one of Selectable's
 /// base classes:
 ///
-/// {@macro moor_multi_selectable_example}
+/// {@macro drift_multi_selectable_example}
-/// {@macro moor_single_selectable_example}
+/// {@macro drift_single_selectable_example}
-/// {@macro moor_single_or_null_selectable_example}
+/// {@macro drift_single_or_null_selectable_example}
 abstract class Selectable<T>
     implements
         MultiSelectable<T>,
@@ -295,7 +295,7 @@ mixin SingleTableQueryMixin<T extends HasResultSet, D> on Query<T, D> {
   /// will be the conjunction of both calls.
   ///
   /// For more information, see:
-  ///  - The docs on [expressions](https://moor.simonbinder.eu/docs/getting-started/expressions/),
+  ///  - The docs on [expressions](https://drift.simonbinder.eu/docs/getting-started/expressions/),
   ///    which explains how to express most SQL expressions in Dart.
   /// If you want to remove duplicate rows from a query, use the `distinct`
   /// parameter on [DatabaseConnectionUser.select].

drift/lib/src/runtime/query_builder/statements/select/custom_select.dart

@@ -1,7 +1,7 @@
 part of '../../query_builder.dart';
 
 /// A select statement that is constructed with a raw sql prepared statement
-/// instead of the high-level moor api.
+/// instead of the high-level drift api.
 class CustomSelectStatement with Selectable<QueryRow> {
   /// Tables this select statement reads from. When turning this select query
   /// into an auto-updating stream, that stream will emit new items whenever

drift/lib/src/runtime/query_builder/statements/select/select.dart

@@ -4,7 +4,7 @@ part of '../../query_builder.dart';
 /// a table.
 typedef OrderClauseGenerator<T> = OrderingTerm Function(T tbl);
 
-/// The abstract base class for all select statements in the moor api.
+/// The abstract base class for all select statements in the drift api.
 ///
 /// Users are not allowed to extend, implement or mix-in this class.
 @sealed
@@ -22,7 +22,7 @@ class SimpleSelectStatement<T extends HasResultSet, D> extends Query<T, D>
   /// `SELECT DISTINCT` statement in sql). Defaults to false.
   final bool distinct;
 
-  /// Used internally by moor, users will want to call
+  /// Used internally by drift, users will want to call
   /// [DatabaseConnectionUser.select] instead.
   SimpleSelectStatement(
       DatabaseConnectionUser database, ResultSetImplementation<T, D> table,
@@ -91,7 +91,7 @@ class SimpleSelectStatement<T extends HasResultSet, D> extends Query<T, D>
   /// ```
   ///
   /// See also:
-  ///  - https://moor.simonbinder.eu/docs/advanced-features/joins/#joins
+  ///  - https://drift.simonbinder.eu/docs/advanced-features/joins/#joins
   ///  - [innerJoin], [leftOuterJoin] and [crossJoin], which can be used to
   ///  construct a [Join].
   ///  - [DatabaseConnectionUser.alias], which can be used to build statements
@@ -112,7 +112,7 @@ class SimpleSelectStatement<T extends HasResultSet, D> extends Query<T, D>
     return statement;
   }
 
-  /// {@macro moor_select_addColumns}
+  /// {@macro drift_select_addColumns}
   JoinedSelectStatement addColumns(List<Expression> expressions) {
     return join([])..addColumns(expressions);
   }
@@ -163,7 +163,7 @@ class TypedResult {
       throw ArgumentError(
           'Invalid table passed to readTable: ${table.aliasedName}. This row '
           'does not contain values for that table. \n'
-          'In moor version 4, you have to use readTableNull for outer joins.');
+          'Please use readTableOrNull for outer joins.');
     }
 
     return _parsedData[table] as D;

drift/lib/src/runtime/query_builder/statements/select/select_with_join.dart

@@ -8,7 +8,7 @@ class JoinedSelectStatement<FirstT extends HasResultSet, FirstD>
     extends Query<FirstT, FirstD>
     with LimitContainerMixin, Selectable<TypedResult>
     implements BaseSelectStatement {
-  /// Used internally by moor, users should use [SimpleSelectStatement.join]
+  /// Used internally by drift, users should use [SimpleSelectStatement.join]
   /// instead.
   JoinedSelectStatement(DatabaseConnectionUser database,
       ResultSetImplementation<FirstT, FirstD> table, this._joins,
@@ -141,7 +141,7 @@ class JoinedSelectStatement<FirstT extends HasResultSet, FirstD>
     orderByExpr = OrderBy(terms);
   }
 
-  /// {@template moor_select_addColumns}
+  /// {@template drift_select_addColumns}
   /// Adds a custom expression to the query.
   ///
   /// The database will evaluate the [Expression] for each row found for this
@@ -158,7 +158,7 @@ class JoinedSelectStatement<FirstT extends HasResultSet, FirstD>
   /// ```
   ///
   /// See also:
-  ///  - The docs on expressions: https://moor.simonbinder.eu/docs/getting-started/expressions/
+  ///  - The docs on expressions: https://drift.simonbinder.eu/docs/getting-started/expressions/
   /// {@endtemplate}
   void addColumns(Iterable<Expression> expressions) {
     _selectedColumns.addAll(expressions);
@@ -169,7 +169,7 @@ class JoinedSelectStatement<FirstT extends HasResultSet, FirstD>
   /// Always returns the same instance.
   ///
   /// See also:
-  ///  - https://moor.simonbinder.eu/docs/advanced-features/joins/#joins
+  ///  - https://drift.simonbinder.eu/docs/advanced-features/joins/#joins
   ///  - [SimpleSelectStatement.join], which is used for the first join
   ///  - [innerJoin], [leftOuterJoin] and [crossJoin], which can be used to
   ///  construct a [Join].
@@ -259,7 +259,7 @@ class JoinedSelectStatement<FirstT extends HasResultSet, FirstD>
       message: 'This query contained the table ${table.entityName} more than '
           'once. Is this a typo? \n'
           'If you need a join that includes the same table more than once, you '
-          'need to alias() at least one table. See https://moor.simonbinder.eu/queries/joins#aliases '
+          'need to alias() at least one table. See https://drift.simonbinder.eu/queries/joins#aliases '
           'for an example.',
       cause: cause,
       trace: trace,

drift/lib/src/runtime/query_builder/statements/update.dart

@@ -3,7 +3,7 @@ part of '../query_builder.dart';
 /// Represents an `UPDATE` statement in sql.
 class UpdateStatement<T extends Table, D> extends Query<T, D>
     with SingleTableQueryMixin<T, D> {
-  /// Used internally by moor, construct an update statement
+  /// Used internally by drift, construct an update statement
   UpdateStatement(DatabaseConnectionUser database, TableInfo<T, D> table)
       : super(database, table);
 
@@ -55,7 +55,7 @@ class UpdateStatement<T extends Table, D> extends Query<T, D>
   ///
   /// When [dontExecute] is true (defaults to false), the query will __NOT__ be
   /// run, but all the validations are still in place. This is mainly used
-  /// internally by moor.
+  /// internally by drift.
   ///
   /// Returns the amount of rows that have been affected by this operation.
   ///
@@ -89,7 +89,7 @@ class UpdateStatement<T extends Table, D> extends Query<T, D>
   ///
   /// When [dontExecute] is true (defaults to false), the query will __NOT__ be
   /// run, but all the validations are still in place. This is mainly used
-  /// internally by moor.
+  /// internally by drift.
   ///
   /// Returns true if a row was affected by this operation.
   ///

drift/lib/src/runtime/types/custom_type.dart

@@ -3,7 +3,7 @@ part of 'sql_types.dart';
 /// Maps a custom dart object of type [D] into a primitive type [S] understood
 /// by the sqlite backend.
 ///
-/// Moor currently supports [DateTime], [double], [int], [Uint8List], [bool]
+/// Dart currently supports [DateTime], [double], [int], [Uint8List], [bool]
 /// and [String] for [S].
 ///
 /// Also see [BuildColumn.map] for details.

drift/lib/src/runtime/types/type_system.dart

@@ -52,7 +52,7 @@ class SqlTypeSystem {
   static String mapToSqlConstant(Object? dart) {
     if (dart == null) return 'NULL';
 
-    // todo: Inline and remove types in the next major moor version
+    // todo: Inline and remove types in the next major drift version
     if (dart is bool) {
       return const BoolType().mapToSqlConstant(dart);
     } else if (dart is String) {

drift/lib/src/web/sql_js.dart

@@ -4,8 +4,8 @@ import 'dart:js';
 import 'dart:typed_data';
 
 // We write our own mapping code to js instead of depending on package:js
-// This way, projects using moor can run on flutter as long as they don't import
+// This way, projects using drift can run on flutter as long as they don't
-// this file.
+// import this file.
 
 Completer<SqlJsModule>? _moduleCompleter;
 
@@ -17,10 +17,10 @@ Future<SqlJsModule> initSqlJs() {
 
   _moduleCompleter = Completer();
   if (!context.hasProperty('initSqlJs')) {
-    return Future.error(
+    return Future.error(UnsupportedError(
-        UnsupportedError('Could not access the sql.js javascript library. '
+        'Could not access the sql.js javascript library. '
-            'The moor documentation contains instructions on how to setup moor '
+        'The drift documentation contains instructions on how to setup drift '
-            'the web, which might help you fix this.'));
+        'the web, which might help you fix this.'));
   }
 
   (context.callMethod('initSqlJs') as JsObject)

drift/lib/src/web/storage.dart

@@ -1,6 +1,6 @@
 part of 'package:drift/web.dart';
 
-/// Interface to control how moor should store data on the web.
+/// Interface to control how drift should store data on the web.
 abstract class DriftWebStorage {
   /// Opens the storage implementation.
   Future<void> open();
@@ -74,7 +74,7 @@ abstract class DriftWebStorage {
           // Try opening a mock database to check if IndexedDB is really
           // available. This avoids the problem with Firefox incorrectly
           // reporting IndexedDB as supported in private mode.
-          final mockDb = await window.indexedDB!.open('moor_mock_db');
+          final mockDb = await window.indexedDB!.open('drift_mock_db');
           mockDb.close();
         }
       } catch (error) {

drift/lib/src/web/web_db.dart

@@ -5,7 +5,7 @@ part of 'package:drift/web.dart';
 /// The bytes returned should represent a valid sqlite3 database file.
 typedef CreateWebDatabase = Future<Uint8List> Function();
 
-/// Experimental moor backend for the web. To use this platform, you need to
+/// Experimental drift backend for the web. To use this platform, you need to
 /// include the latest version of `sql.js` in your html.
 class WebDatabase extends DelegatedDatabase {
   /// A database executor that works on the web.
@@ -183,7 +183,7 @@ class _WebVersionDelegate extends DynamicVersionDelegate {
 
   _WebVersionDelegate(this.delegate);
 
-  // Note: Earlier moor versions used to store the database version in a special
+  // Note: Earlier versions used to store the database version in a special
   // field in local storage (moor_db_version_<name>). Since 2.3, we instead use
   // the user_version pragma, but still need to keep backwards compatibility.
 

drift/lib/web.dart

@@ -1,9 +1,9 @@
-/// A version of moor that runs on the web by using [sql.js](https://github.com/sql-js/sql.js)
+/// A version of drift that runs on the web by using [sql.js](https://github.com/sql-js/sql.js)
 /// You manually need to include that library into your website to use the
-/// web version of moor. See [the documentation](https://moor.simonbinder.eu/web)
+/// web version of drift. See [the documentation](https://drift.simonbinder.eu/web)
 /// for a more detailed instruction.
 @experimental
-library moor_web;
+library drift.web;
 
 import 'dart:async';
 import 'dart:html';

drift/test/data/tables/custom_tables.dart

@@ -8,7 +8,7 @@ export 'data_classes.dart';
 part 'custom_tables.g.dart';
 
 @DriftDatabase(
-  include: {'tables.moor'},
+  include: {'tables.drift'},
   queries: {
     'writeConfig': 'REPLACE INTO config (config_key, config_value) '
         'VALUES (:key, :value)'

drift/test/engines/connection_pool_integration_test.dart

@@ -9,7 +9,7 @@ import 'package:test/test.dart';
 
 import '../data/tables/todos.dart';
 
-String fileName = 'moor-wal-integration-test.db';
+String fileName = 'drift-wal-integration-test.db';
 final _file = File(join(Directory.systemTemp.path, fileName));
 
 QueryExecutor _createExecutor() => NativeDatabase(_file);

drift/test/expressions/null_check_test.dart

@@ -1,5 +1,5 @@
 import 'package:drift/drift.dart';
-import 'package:drift/drift.dart' as moor;
+import 'package:drift/drift.dart' as drift;
 import 'package:test/test.dart';
 
 import '../data/utils/expect_equality.dart';
@@ -10,7 +10,7 @@ void main() {
       CustomExpression<int>('name', precedence: Precedence.primary);
 
   test('IS NULL expressions are generated', () {
-    final oldFunction = moor.isNull(innerExpression);
+    final oldFunction = drift.isNull(innerExpression);
     final extension = innerExpression.isNull();
 
     expect(oldFunction, generates('name IS NULL'));
@@ -20,7 +20,7 @@ void main() {
   });
 
   test('IS NOT NULL expressions are generated', () {
-    final oldFunction = moor.isNotNull(innerExpression);
+    final oldFunction = drift.isNotNull(innerExpression);
     final extension = innerExpression.isNotNull();
 
     expect(oldFunction, generates('name IS NOT NULL'));
@@ -30,7 +30,8 @@ void main() {
   });
 
   test('generates COALESCE expressions', () {
-    final expr = moor.coalesce([const Constant<int?>(null), const Constant(3)]);
+    final expr =
+        drift.coalesce([const Constant<int?>(null), const Constant(3)]);
 
     expect(expr, generates('COALESCE(NULL, 3)'));
   });

drift/test/ffi/close_existing_test.dart

@@ -8,7 +8,7 @@ import 'package:test/test.dart';
 
 void main() {
   test('can close lost instances', () async {
-    final file = File(p.join(Directory.systemTemp.path, 'moor_close.db'));
+    final file = File(p.join(Directory.systemTemp.path, 'drift_close.db'));
     if (file.existsSync()) file.deleteSync();
 
     // Create the first database holding the lock

drift/test/ffi/moor_functions_test.dart

@@ -1,14 +1,14 @@
 @TestOn('vm')
 import 'dart:math';
 
-import 'package:drift/src/ffi/moor_ffi_functions.dart';
+import 'package:drift/src/ffi/native_functions.dart';
 import 'package:sqlite3/sqlite3.dart';
 import 'package:test/test.dart';
 
 void main() {
   late Database db;
 
-  setUp(() => db = sqlite3.openInMemory()..useMoorVersions());
+  setUp(() => db = sqlite3.openInMemory()..useNativeFunctions());
   tearDown(() => db.dispose());
 
   dynamic selectSingle(String expression) {

drift/test/integration_tests/moor_files_test.dart

@@ -51,7 +51,7 @@ const _defaultInsert = 'INSERT INTO config (config_key, config_value) '
     "VALUES ('key', 'values')";
 
 void main() {
-  // see ../data/tables/tables.moor
+  // see ../data/tables/tables.drift
   late MockExecutor mock;
   late CustomTablesDb db;
 
@@ -62,7 +62,7 @@ void main() {
 
   tearDown(() => db.close());
 
-  test('creates everything as specified in .moor files', () async {
+  test('creates everything as specified in .drift files', () async {
     await db.createMigrator().createAll();
 
     verify(mock.runCustom(_createNoIds, []));

drift/test/isolate_test.dart

@@ -10,9 +10,9 @@ import 'package:test/test.dart';
 import 'data/tables/todos.dart';
 
 void main() {
-  // Using the MoorIsolate apis without actually running on a background isolate
+  // Using the DriftIsolate apis without actually running on a background
-  // is pointless, but we can't collect coverage for background isolates:
+  // isolate is pointless, but we can't collect coverage for background
-  // https://github.com/dart-lang/test/issues/1108
+  // isolates: https://github.com/dart-lang/test/issues/1108
   group('in same isolate', () {
     DriftIsolate spawnInSame() {
       return DriftIsolate.inCurrent(_backgroundConnection);
@@ -33,14 +33,14 @@ void main() {
     // three isolates:
     // 1. this one, starting a query stream
     // 2. another one running an insert
-    // 3. the MoorIsolate executor the other two are connecting to
+    // 3. the DriftIsolate executor the other two are connecting to
-    final moorIsolate = await DriftIsolate.spawn(_backgroundConnection);
+    final driftIsolate = await DriftIsolate.spawn(_backgroundConnection);
 
     final receiveDone = ReceivePort();
     final writer = await Isolate.spawn(_writeTodoEntryInBackground,
-        _BackgroundEntryMessage(moorIsolate, receiveDone.sendPort));
+        _BackgroundEntryMessage(driftIsolate, receiveDone.sendPort));
 
-    final db = TodoDb.connect(await moorIsolate.connect());
+    final db = TodoDb.connect(await driftIsolate.connect());
     final expectedEntry = const TypeMatcher<TodoEntry>()
         .having((e) => e.content, 'content', 'Hello from background');
 
@@ -57,7 +57,7 @@ void main() {
     await receiveDone.first;
     writer.kill();
     await expectation;
-    await moorIsolate.shutdownAll();
+    await driftIsolate.shutdownAll();
   }, tags: 'background_isolate');
 
   test('errors propagate across isolates', () async {
@@ -88,8 +88,8 @@ void main() {
     // The isolate shold eventually exit!
     expect(done.first, completion(anything));
 
-    final moor = await spawned.first as DriftIsolate;
+    final drift = await spawned.first as DriftIsolate;
-    await moor.shutdownAll();
+    await drift.shutdownAll();
   }, tags: 'background_isolate');
 }
 
@@ -282,8 +282,8 @@ class _BackgroundEntryMessage {
 }
 
 void _createBackground(SendPort send) {
-  final moor = DriftIsolate.inCurrent(
+  final drift = DriftIsolate.inCurrent(
       () => DatabaseConnection.fromExecutor(NativeDatabase.memory()),
       killIsolateWhenDone: true);
-  send.send(moor);
+  send.send(drift);
 }

drift/test/streams_test.dart

@@ -330,7 +330,7 @@ void main() {
     expect(db.customSelect('SELECT 1').watchSingle().isBroadcast, isTrue);
   });
 
-  test('moor streams can be used with switchMap in rxdart', () async {
+  test('drift streams can be used with switchMap in rxdart', () async {
     // Regression test for https://github.com/simolus3/moor/issues/500
     when(executor.runSelect(any, any)).thenAnswer((i) async {
       final sql = i.positionalArguments.first as String;

drift/test/types/datetime_test.dart

@@ -1,4 +1,4 @@
-import 'package:drift/drift.dart' as moor;
+import 'package:drift/drift.dart' as drift;
 import 'package:test/test.dart';
 
 const _exampleUnixSqlite = 1550172560;
@@ -7,7 +7,7 @@ final _exampleDateTime =
     DateTime.fromMillisecondsSinceEpoch(_exampleUnixMillis);
 
 void main() {
-  const type = moor.DateTimeType();
+  const type = drift.DateTimeType();
 
   group('DateTimes', () {
     test('can be read from unix stamps returned by sql', () {

drift/test/types/real_type_test.dart

@@ -1,8 +1,8 @@
-import 'package:drift/drift.dart' as moor;
+import 'package:drift/drift.dart' as drift;
 import 'package:test/test.dart';
 
 void main() {
-  const type = moor.RealType();
+  const type = drift.RealType();
 
   group('RealType', () {
     test('can be read from floating point values returned by sql', () {