Feature/raw query

example/lib/task_dao.dart

@@ -12,6 +12,23 @@ abstract class TaskDao {
   @Query('SELECT * FROM task')
   Stream<List<Task>> findAllTasksAsStream();
 
+  @rawQuery
+  Stream<List<Task>> rawQueryTasksAsStream(SQLiteQuery query);
+
+  Stream<List<Task>> findYesterdaysTasksByMessageAsStream(String message) {
+    final timestamp = DateTime.now()
+        .subtract(
+          const Duration(days: 1),
+        )
+        .millisecondsSinceEpoch;
+    return rawQueryTasksAsStream(SQLiteQuery(
+        'SELECT * FROM task WHERE timestamp > ?1 AND message == ?2',
+        arguments: [
+          timestamp,
+          message,
+        ]));
+  }
+
   @insert
   Future<void> insertTask(Task task);
 

floor/lib/floor.dart

@@ -10,3 +10,4 @@ export 'package:floor/src/database.dart';
 export 'package:floor/src/migration.dart';
 export 'package:floor/src/sqflite_database_factory.dart';
 export 'package:floor_annotation/floor_annotation.dart';
+export 'package:floor_generator/value_object/sqlite_query.dart';

floor_annotation/lib/floor_annotation.dart

@@ -14,6 +14,7 @@ export 'src/insert.dart';
 export 'src/on_conflict_strategy.dart';
 export 'src/primary_key.dart';
 export 'src/query.dart';
+export 'src/raw_query.dart';
 export 'src/transaction.dart';
 export 'src/type_converter.dart';
 export 'src/type_converters.dart';

floor_annotation/lib/src/raw_query.dart

@@ -0,0 +1,5 @@
+class RawQuery {
+  const RawQuery();
+}
+
+const rawQuery = RawQuery();

floor_generator/lib/misc/type_utils.dart

@@ -3,6 +3,7 @@ import 'dart:typed_data';
 import 'package:analyzer/dart/constant/value.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
+import 'package:floor_generator/value_object/sqlite_query.dart';
 import 'package:source_gen/source_gen.dart';
 
 extension SupportedTypeChecker on DartType {
@@ -19,6 +20,7 @@ extension SupportedTypeChecker on DartType {
       _intTypeChecker,
       _doubleTypeChecker,
       _uint8ListTypeChecker,
+      _sqliteQueryTypeChecker,
     ]).isExactlyType(this);
   }
 }
@@ -28,6 +30,11 @@ extension Uint8ListTypeChecker on DartType {
       getDisplayString(withNullability: false) == 'Uint8List';
 }
 
+extension SQLiteQueryTypeChecker on DartType {
+  bool get isSQLiteQuery =>
+      getDisplayString(withNullability: false) == 'SQLiteQuery';
+}
+
 extension StreamTypeChecker on DartType {
   bool get isStream => _streamTypeChecker.isExactlyType(this);
 }
@@ -43,6 +50,13 @@ extension AnnotationChecker on Element {
     return _typeChecker(type).hasAnnotationOfExact(this);
   }
 
+  bool containsAnnotation(final List<Type> types) {
+    return types.firstWhere(
+            (type) => _typeChecker(type).hasAnnotationOfExact(this),
+            orElse: () => null.runtimeType) !=
+        null.runtimeType;
+  }
+
   /// Returns the first annotation object found of [type]
   /// or `null` if annotation of [type] not found
   DartObject? getAnnotation(final Type type) {
@@ -63,3 +77,5 @@ final _doubleTypeChecker = _typeChecker(double);
 final _uint8ListTypeChecker = _typeChecker(Uint8List);
 
 final _streamTypeChecker = _typeChecker(Stream);
+
+final _sqliteQueryTypeChecker = _typeChecker(SQLiteQuery);

floor_generator/lib/processor/base_query_method_processor.dart

@@ -0,0 +1,108 @@
+import 'package:analyzer/dart/element/element.dart';
+import 'package:analyzer/dart/element/type.dart';
+import 'package:collection/collection.dart';
+import 'package:floor_generator/misc/extension/dart_type_extension.dart';
+import 'package:floor_generator/misc/type_utils.dart';
+import 'package:floor_generator/processor/error/base_query_method_processor_error.dart';
+import 'package:floor_generator/processor/processor.dart';
+import 'package:floor_generator/value_object/query_method.dart';
+import 'package:floor_generator/value_object/queryable.dart';
+
+abstract class BaseQueryMethodProcessor extends Processor<QueryMethod> {
+  final MethodElement _methodElement;
+  final List<Queryable> _queryables;
+  final BaseQueryMethodProcessorError _processorError;
+
+  BaseQueryMethodProcessor(
+    final MethodElement methodElement,
+    final List<Queryable> queryables,
+  )   : _methodElement = methodElement,
+        _queryables = queryables,
+        _processorError = BaseQueryMethodProcessorError(methodElement);
+
+  @override
+  QueryMethod process() {
+    final name = _methodElement.displayName;
+    final parameters = _methodElement.parameters;
+    final returnType = _methodElement.returnType;
+    final returnsStream = returnType.isStream;
+    _assertReturnsFutureOrStream(returnType, returnsStream);
+    final returnsList = _getReturnsList(returnType, returnsStream);
+
+    final flattenedReturnType = _getFlattenedReturnType(
+      returnType,
+      returnsStream,
+      returnsList,
+    );
+
+    _assertReturnsNullableSingle(
+      returnsStream,
+      returnsList,
+      flattenedReturnType,
+    );
+
+    final queryable = _queryables.firstWhereOrNull((queryable) =>
+        queryable.classElement.displayName ==
+        flattenedReturnType.getDisplayString(withNullability: false));
+
+    return onProcess(
+      _methodElement,
+      name,
+      returnType,
+      flattenedReturnType,
+      parameters,
+      queryable,
+    );
+  }
+
+  DartType _getFlattenedReturnType(
+    final DartType rawReturnType,
+    final bool returnsStream,
+    final bool returnsList,
+  ) {
+    final type = returnsStream
+        ? _methodElement.returnType.flatten()
+        : _methodElement.library.typeSystem.flatten(rawReturnType);
+    return returnsList ? type.flatten() : type;
+  }
+
+  bool _getReturnsList(final DartType returnType, final bool returnsStream) {
+    final type = returnsStream
+        ? returnType.flatten()
+        : _methodElement.library.typeSystem.flatten(returnType);
+
+    return type.isDartCoreList;
+  }
+
+  void _assertReturnsFutureOrStream(
+    final DartType rawReturnType,
+    final bool returnsStream,
+  ) {
+    if (!rawReturnType.isDartAsyncFuture && !returnsStream) {
+      throw _processorError.doesNotReturnFutureNorStream;
+    }
+  }
+
+  void _assertReturnsNullableSingle(
+    final bool returnsStream,
+    final bool returnsList,
+    final DartType flattenedReturnType,
+  ) {
+    if (!returnsList &&
+        !flattenedReturnType.isVoid &&
+        !flattenedReturnType.isNullable) {
+      returnsStream
+          ? throw _processorError.doesNotReturnNullableStream
+          : throw _processorError.doesNotReturnNullableFuture;
+    }
+  }
+
+  QueryMethod onProcess(
+    MethodElement methodElement,
+    String name,
+    DartType returnType,
+    DartType flattenedReturnType,
+    List<ParameterElement> parameters,
+    Queryable? queryable,
+  );
+}

floor_generator/lib/processor/dao_processor.dart

@@ -7,6 +7,7 @@ import 'package:floor_generator/processor/deletion_method_processor.dart';
 import 'package:floor_generator/processor/insertion_method_processor.dart';
 import 'package:floor_generator/processor/processor.dart';
 import 'package:floor_generator/processor/query_method_processor.dart';
+import 'package:floor_generator/processor/raw_query_method_processor.dart';
 import 'package:floor_generator/processor/transaction_method_processor.dart';
 import 'package:floor_generator/processor/update_method_processor.dart';
 import 'package:floor_generator/value_object/dao.dart';
@@ -83,13 +84,24 @@ class DaoProcessor extends Processor<Dao> {
     final Set<TypeConverter> typeConverters,
   ) {
     return methods
-        .where((method) => method.hasAnnotation(annotations.Query))
-        .map((method) => QueryMethodProcessor(
-              method,
-              [..._entities, ..._views],
-              typeConverters,
-            ).process())
-        .toList();
+        .where((method) => method.containsAnnotation([
+              annotations.Query,
+              annotations.RawQuery,
+            ]))
+        .map((method) {
+      if (method.hasAnnotation(annotations.Query)) {
+        return QueryMethodProcessor(
+          method,
+          [..._entities, ..._views],
+          typeConverters,
+        ).process();
+      } else {
+        return RawQueryMethodProcessor(
+          method,
+          [..._entities, ..._views],
+        ).process();
+      }
+    }).toList();
   }
 
   List<InsertionMethod> _getInsertionMethods(

floor_generator/lib/processor/error/base_query_method_processor_error.dart

@@ -0,0 +1,36 @@
+import 'package:analyzer/dart/element/element.dart';
+import 'package:floor_generator/processor/error/processor_error.dart';
+import 'package:source_gen/source_gen.dart';
+
+class BaseQueryMethodProcessorError {
+  final MethodElement _methodElement;
+
+  BaseQueryMethodProcessorError(final MethodElement methodElement)
+      : _methodElement = methodElement;
+
+  InvalidGenerationSourceError get doesNotReturnFutureNorStream {
+    return InvalidGenerationSourceError(
+      'All queries have to return a Future or Stream.',
+      todo: 'Define the return type as Future or Stream.',
+      element: _methodElement,
+    );
+  }
+
+  ProcessorError get doesNotReturnNullableStream {
+    return ProcessorError(
+      message: 'Queries returning streams of single elements might emit null.',
+      todo:
+          'Make the method return a Stream of a nullable type e.g. Stream<Person?>.',
+      element: _methodElement,
+    );
+  }
+
+  ProcessorError get doesNotReturnNullableFuture {
+    return ProcessorError(
+      message: 'Queries returning single elements might return null.',
+      todo:
+          'Make the method return a Future of a nullable type e.g. Future<Person?>.',
+      element: _methodElement,
+    );
+  }
+}

floor_generator/lib/processor/error/query_method_processor_error.dart

@@ -1,5 +1,4 @@
 import 'package:analyzer/dart/element/element.dart';
-import 'package:floor_generator/processor/error/processor_error.dart';
 import 'package:source_gen/source_gen.dart';
 
 class QueryMethodProcessorError {
@@ -23,22 +22,4 @@ class QueryMethodProcessorError {
       element: _methodElement,
     );
   }
-
-  ProcessorError get doesNotReturnNullableStream {
-    return ProcessorError(
-      message: 'Queries returning streams of single elements might emit null.',
-      todo:
-          'Make the method return a Stream of a nullable type e.g. Stream<Person?>.',
-      element: _methodElement,
-    );
-  }
-
-  ProcessorError get doesNotReturnNullableFuture {
-    return ProcessorError(
-      message: 'Queries returning single elements might return null.',
-      todo:
-          'Make the method return a Future of a nullable type e.g. Future<Person?>.',
-      element: _methodElement,
-    );
-  }
 }

floor_generator/lib/processor/error/raw_query_method_processor_error.dart

@@ -0,0 +1,30 @@
+import 'package:analyzer/dart/element/element.dart';
+import 'package:floor_generator/processor/error/processor_error.dart';
+import 'package:source_gen/source_gen.dart';
+
+class RawQueryMethodProcessorError {
+  final MethodElement _methodElement;
+
+  RawQueryMethodProcessorError(final MethodElement methodElement)
+      : _methodElement = methodElement;
+
+  InvalidGenerationSourceError get queryArgumentsShouldBeSingle {
+    return InvalidGenerationSourceError(
+      'RawQuery methods should have 1 and only 1 parameter with type String or SQLiteQuery',
+      todo: 'Make sure to supply one parameter per SQL query argument.',
+      element: _methodElement,
+    );
+  }
+
+  ProcessorError queryMethodParameterIsNullable(
+    final ParameterElement parameterElement,
+  ) {
+    return ProcessorError(
+      message: 'Query method parameters have to be non-nullable.',
+      todo: 'Define ${parameterElement.displayName} as non-nullable.'
+          '\nIf you want to assert null, change your query to use the `IS NULL`/'
+          '`IS NOT NULL` operator without passing a nullable parameter.',
+      element: _methodElement,
+    );
+  }
+}

floor_generator/lib/processor/field_processor.dart

@@ -78,7 +78,7 @@ extension on DartType {
       return SqlType.integer;
     } else if (isDartCoreDouble) {
       return SqlType.real;
-    } else if (isUint8List) {
+    } else if (isUint8List || isSQLiteQuery) {
       return SqlType.blob;
     }
     throw StateError('This should really be unreachable');