mirror of https://github.com/AMT-Cheif/drift.git
600 lines
19 KiB
Dart
600 lines
19 KiB
Dart
// GENERATED CODE - DO NOT MODIFY BY HAND
|
|
|
|
part of 'example.dart';
|
|
|
|
// **************************************************************************
|
|
// MoorGenerator
|
|
// **************************************************************************
|
|
|
|
// ignore_for_file: unnecessary_brace_in_string_interps
|
|
class Category {
|
|
final int id;
|
|
final String description;
|
|
Category({this.id, this.description});
|
|
factory Category.fromData(Map<String, dynamic> data, GeneratedDatabase db,
|
|
{String prefix}) {
|
|
final effectivePrefix = prefix ?? '';
|
|
final intType = db.typeSystem.forDartType<int>();
|
|
final stringType = db.typeSystem.forDartType<String>();
|
|
return Category(
|
|
id: intType.mapFromDatabaseResponse(data['${effectivePrefix}id']),
|
|
description: stringType
|
|
.mapFromDatabaseResponse(data['${effectivePrefix}description']),
|
|
);
|
|
}
|
|
factory Category.fromJson(Map<String, dynamic> json) {
|
|
return Category(
|
|
id: json['id'] as int,
|
|
description: json['description'] as String,
|
|
);
|
|
}
|
|
Map<String, dynamic> toJson() {
|
|
return {
|
|
'id': id,
|
|
'description': description,
|
|
};
|
|
}
|
|
|
|
Category copyWith({int id, String description}) => Category(
|
|
id: id ?? this.id,
|
|
description: description ?? this.description,
|
|
);
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('Category(')
|
|
..write('id: $id, ')
|
|
..write('description: $description')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
|
|
@override
|
|
int get hashCode =>
|
|
$moorjf($mrjf($mrjc(0, id.hashCode), description.hashCode));
|
|
@override
|
|
bool operator ==(other) =>
|
|
identical(this, other) ||
|
|
(other is Category && other.id == id && other.description == description);
|
|
}
|
|
|
|
class $CategoriesTable extends Categories
|
|
with TableInfo<$CategoriesTable, Category> {
|
|
final GeneratedDatabase _db;
|
|
final String _alias;
|
|
$CategoriesTable(this._db, [this._alias]);
|
|
GeneratedIntColumn _id;
|
|
@override
|
|
GeneratedIntColumn get id => _id ??= _constructId();
|
|
GeneratedIntColumn _constructId() {
|
|
var cName = 'id';
|
|
if (_alias != null) cName = '$_alias.$cName';
|
|
return GeneratedIntColumn('id', $tableName, false, hasAutoIncrement: true);
|
|
}
|
|
|
|
GeneratedTextColumn _description;
|
|
@override
|
|
GeneratedTextColumn get description =>
|
|
_description ??= _constructDescription();
|
|
GeneratedTextColumn _constructDescription() {
|
|
var cName = 'description';
|
|
if (_alias != null) cName = '$_alias.$cName';
|
|
return GeneratedTextColumn(
|
|
'description',
|
|
$tableName,
|
|
true,
|
|
);
|
|
}
|
|
|
|
@override
|
|
List<GeneratedColumn> get $columns => [id, description];
|
|
@override
|
|
$CategoriesTable get asDslTable => this;
|
|
@override
|
|
String get $tableName => _alias ?? 'categories';
|
|
@override
|
|
final String actualTableName = 'categories';
|
|
@override
|
|
bool validateIntegrity(Category instance, bool isInserting) =>
|
|
id.isAcceptableValue(instance.id, isInserting) &&
|
|
description.isAcceptableValue(instance.description, isInserting);
|
|
@override
|
|
Set<GeneratedColumn> get $primaryKey => {id};
|
|
@override
|
|
Category map(Map<String, dynamic> data, {String tablePrefix}) {
|
|
final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : null;
|
|
return Category.fromData(data, _db, prefix: effectivePrefix);
|
|
}
|
|
|
|
@override
|
|
Map<String, Variable> entityToSql(Category d, {bool includeNulls = false}) {
|
|
final map = <String, Variable>{};
|
|
if (d.id != null || includeNulls) {
|
|
map['id'] = Variable<int, IntType>(d.id);
|
|
}
|
|
if (d.description != null || includeNulls) {
|
|
map['description'] = Variable<String, StringType>(d.description);
|
|
}
|
|
return map;
|
|
}
|
|
|
|
@override
|
|
$CategoriesTable createAlias(String alias) {
|
|
return $CategoriesTable(_db, alias);
|
|
}
|
|
}
|
|
|
|
class Recipe {
|
|
final int id;
|
|
final String title;
|
|
final String instructions;
|
|
final int category;
|
|
Recipe({this.id, this.title, this.instructions, this.category});
|
|
factory Recipe.fromData(Map<String, dynamic> data, GeneratedDatabase db,
|
|
{String prefix}) {
|
|
final effectivePrefix = prefix ?? '';
|
|
final intType = db.typeSystem.forDartType<int>();
|
|
final stringType = db.typeSystem.forDartType<String>();
|
|
return Recipe(
|
|
id: intType.mapFromDatabaseResponse(data['${effectivePrefix}id']),
|
|
title:
|
|
stringType.mapFromDatabaseResponse(data['${effectivePrefix}title']),
|
|
instructions: stringType
|
|
.mapFromDatabaseResponse(data['${effectivePrefix}instructions']),
|
|
category:
|
|
intType.mapFromDatabaseResponse(data['${effectivePrefix}category']),
|
|
);
|
|
}
|
|
factory Recipe.fromJson(Map<String, dynamic> json) {
|
|
return Recipe(
|
|
id: json['id'] as int,
|
|
title: json['title'] as String,
|
|
instructions: json['instructions'] as String,
|
|
category: json['category'] as int,
|
|
);
|
|
}
|
|
Map<String, dynamic> toJson() {
|
|
return {
|
|
'id': id,
|
|
'title': title,
|
|
'instructions': instructions,
|
|
'category': category,
|
|
};
|
|
}
|
|
|
|
Recipe copyWith({int id, String title, String instructions, int category}) =>
|
|
Recipe(
|
|
id: id ?? this.id,
|
|
title: title ?? this.title,
|
|
instructions: instructions ?? this.instructions,
|
|
category: category ?? this.category,
|
|
);
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('Recipe(')
|
|
..write('id: $id, ')
|
|
..write('title: $title, ')
|
|
..write('instructions: $instructions, ')
|
|
..write('category: $category')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
|
|
@override
|
|
int get hashCode => $moorjf($mrjf(
|
|
$mrjf(
|
|
$mrjf($mrjc(0, id.hashCode), title.hashCode), instructions.hashCode),
|
|
category.hashCode));
|
|
@override
|
|
bool operator ==(other) =>
|
|
identical(this, other) ||
|
|
(other is Recipe &&
|
|
other.id == id &&
|
|
other.title == title &&
|
|
other.instructions == instructions &&
|
|
other.category == category);
|
|
}
|
|
|
|
class $RecipesTable extends Recipes with TableInfo<$RecipesTable, Recipe> {
|
|
final GeneratedDatabase _db;
|
|
final String _alias;
|
|
$RecipesTable(this._db, [this._alias]);
|
|
GeneratedIntColumn _id;
|
|
@override
|
|
GeneratedIntColumn get id => _id ??= _constructId();
|
|
GeneratedIntColumn _constructId() {
|
|
var cName = 'id';
|
|
if (_alias != null) cName = '$_alias.$cName';
|
|
return GeneratedIntColumn('id', $tableName, false, hasAutoIncrement: true);
|
|
}
|
|
|
|
GeneratedTextColumn _title;
|
|
@override
|
|
GeneratedTextColumn get title => _title ??= _constructTitle();
|
|
GeneratedTextColumn _constructTitle() {
|
|
var cName = 'title';
|
|
if (_alias != null) cName = '$_alias.$cName';
|
|
return GeneratedTextColumn('title', $tableName, false, maxTextLength: 16);
|
|
}
|
|
|
|
GeneratedTextColumn _instructions;
|
|
@override
|
|
GeneratedTextColumn get instructions =>
|
|
_instructions ??= _constructInstructions();
|
|
GeneratedTextColumn _constructInstructions() {
|
|
var cName = 'instructions';
|
|
if (_alias != null) cName = '$_alias.$cName';
|
|
return GeneratedTextColumn(
|
|
'instructions',
|
|
$tableName,
|
|
false,
|
|
);
|
|
}
|
|
|
|
GeneratedIntColumn _category;
|
|
@override
|
|
GeneratedIntColumn get category => _category ??= _constructCategory();
|
|
GeneratedIntColumn _constructCategory() {
|
|
var cName = 'category';
|
|
if (_alias != null) cName = '$_alias.$cName';
|
|
return GeneratedIntColumn(
|
|
'category',
|
|
$tableName,
|
|
true,
|
|
);
|
|
}
|
|
|
|
@override
|
|
List<GeneratedColumn> get $columns => [id, title, instructions, category];
|
|
@override
|
|
$RecipesTable get asDslTable => this;
|
|
@override
|
|
String get $tableName => _alias ?? 'recipes';
|
|
@override
|
|
final String actualTableName = 'recipes';
|
|
@override
|
|
bool validateIntegrity(Recipe instance, bool isInserting) =>
|
|
id.isAcceptableValue(instance.id, isInserting) &&
|
|
title.isAcceptableValue(instance.title, isInserting) &&
|
|
instructions.isAcceptableValue(instance.instructions, isInserting) &&
|
|
category.isAcceptableValue(instance.category, isInserting);
|
|
@override
|
|
Set<GeneratedColumn> get $primaryKey => {id};
|
|
@override
|
|
Recipe map(Map<String, dynamic> data, {String tablePrefix}) {
|
|
final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : null;
|
|
return Recipe.fromData(data, _db, prefix: effectivePrefix);
|
|
}
|
|
|
|
@override
|
|
Map<String, Variable> entityToSql(Recipe d, {bool includeNulls = false}) {
|
|
final map = <String, Variable>{};
|
|
if (d.id != null || includeNulls) {
|
|
map['id'] = Variable<int, IntType>(d.id);
|
|
}
|
|
if (d.title != null || includeNulls) {
|
|
map['title'] = Variable<String, StringType>(d.title);
|
|
}
|
|
if (d.instructions != null || includeNulls) {
|
|
map['instructions'] = Variable<String, StringType>(d.instructions);
|
|
}
|
|
if (d.category != null || includeNulls) {
|
|
map['category'] = Variable<int, IntType>(d.category);
|
|
}
|
|
return map;
|
|
}
|
|
|
|
@override
|
|
$RecipesTable createAlias(String alias) {
|
|
return $RecipesTable(_db, alias);
|
|
}
|
|
}
|
|
|
|
class Ingredient {
|
|
final int id;
|
|
final String name;
|
|
final int caloriesPer100g;
|
|
Ingredient({this.id, this.name, this.caloriesPer100g});
|
|
factory Ingredient.fromData(Map<String, dynamic> data, GeneratedDatabase db,
|
|
{String prefix}) {
|
|
final effectivePrefix = prefix ?? '';
|
|
final intType = db.typeSystem.forDartType<int>();
|
|
final stringType = db.typeSystem.forDartType<String>();
|
|
return Ingredient(
|
|
id: intType.mapFromDatabaseResponse(data['${effectivePrefix}id']),
|
|
name: stringType.mapFromDatabaseResponse(data['${effectivePrefix}name']),
|
|
caloriesPer100g:
|
|
intType.mapFromDatabaseResponse(data['${effectivePrefix}calories']),
|
|
);
|
|
}
|
|
factory Ingredient.fromJson(Map<String, dynamic> json) {
|
|
return Ingredient(
|
|
id: json['id'] as int,
|
|
name: json['name'] as String,
|
|
caloriesPer100g: json['caloriesPer100g'] as int,
|
|
);
|
|
}
|
|
Map<String, dynamic> toJson() {
|
|
return {
|
|
'id': id,
|
|
'name': name,
|
|
'caloriesPer100g': caloriesPer100g,
|
|
};
|
|
}
|
|
|
|
Ingredient copyWith({int id, String name, int caloriesPer100g}) => Ingredient(
|
|
id: id ?? this.id,
|
|
name: name ?? this.name,
|
|
caloriesPer100g: caloriesPer100g ?? this.caloriesPer100g,
|
|
);
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('Ingredient(')
|
|
..write('id: $id, ')
|
|
..write('name: $name, ')
|
|
..write('caloriesPer100g: $caloriesPer100g')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
|
|
@override
|
|
int get hashCode => $moorjf($mrjf(
|
|
$mrjf($mrjc(0, id.hashCode), name.hashCode), caloriesPer100g.hashCode));
|
|
@override
|
|
bool operator ==(other) =>
|
|
identical(this, other) ||
|
|
(other is Ingredient &&
|
|
other.id == id &&
|
|
other.name == name &&
|
|
other.caloriesPer100g == caloriesPer100g);
|
|
}
|
|
|
|
class $IngredientsTable extends Ingredients
|
|
with TableInfo<$IngredientsTable, Ingredient> {
|
|
final GeneratedDatabase _db;
|
|
final String _alias;
|
|
$IngredientsTable(this._db, [this._alias]);
|
|
GeneratedIntColumn _id;
|
|
@override
|
|
GeneratedIntColumn get id => _id ??= _constructId();
|
|
GeneratedIntColumn _constructId() {
|
|
var cName = 'id';
|
|
if (_alias != null) cName = '$_alias.$cName';
|
|
return GeneratedIntColumn('id', $tableName, false, hasAutoIncrement: true);
|
|
}
|
|
|
|
GeneratedTextColumn _name;
|
|
@override
|
|
GeneratedTextColumn get name => _name ??= _constructName();
|
|
GeneratedTextColumn _constructName() {
|
|
var cName = 'name';
|
|
if (_alias != null) cName = '$_alias.$cName';
|
|
return GeneratedTextColumn(
|
|
'name',
|
|
$tableName,
|
|
false,
|
|
);
|
|
}
|
|
|
|
GeneratedIntColumn _caloriesPer100g;
|
|
@override
|
|
GeneratedIntColumn get caloriesPer100g =>
|
|
_caloriesPer100g ??= _constructCaloriesPer100g();
|
|
GeneratedIntColumn _constructCaloriesPer100g() {
|
|
var cName = 'calories';
|
|
if (_alias != null) cName = '$_alias.$cName';
|
|
return GeneratedIntColumn(
|
|
'calories',
|
|
$tableName,
|
|
false,
|
|
);
|
|
}
|
|
|
|
@override
|
|
List<GeneratedColumn> get $columns => [id, name, caloriesPer100g];
|
|
@override
|
|
$IngredientsTable get asDslTable => this;
|
|
@override
|
|
String get $tableName => _alias ?? 'ingredients';
|
|
@override
|
|
final String actualTableName = 'ingredients';
|
|
@override
|
|
bool validateIntegrity(Ingredient instance, bool isInserting) =>
|
|
id.isAcceptableValue(instance.id, isInserting) &&
|
|
name.isAcceptableValue(instance.name, isInserting) &&
|
|
caloriesPer100g.isAcceptableValue(instance.caloriesPer100g, isInserting);
|
|
@override
|
|
Set<GeneratedColumn> get $primaryKey => {id};
|
|
@override
|
|
Ingredient map(Map<String, dynamic> data, {String tablePrefix}) {
|
|
final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : null;
|
|
return Ingredient.fromData(data, _db, prefix: effectivePrefix);
|
|
}
|
|
|
|
@override
|
|
Map<String, Variable> entityToSql(Ingredient d, {bool includeNulls = false}) {
|
|
final map = <String, Variable>{};
|
|
if (d.id != null || includeNulls) {
|
|
map['id'] = Variable<int, IntType>(d.id);
|
|
}
|
|
if (d.name != null || includeNulls) {
|
|
map['name'] = Variable<String, StringType>(d.name);
|
|
}
|
|
if (d.caloriesPer100g != null || includeNulls) {
|
|
map['calories'] = Variable<int, IntType>(d.caloriesPer100g);
|
|
}
|
|
return map;
|
|
}
|
|
|
|
@override
|
|
$IngredientsTable createAlias(String alias) {
|
|
return $IngredientsTable(_db, alias);
|
|
}
|
|
}
|
|
|
|
class IngredientInRecipe {
|
|
final int recipe;
|
|
final int ingredient;
|
|
final int amountInGrams;
|
|
IngredientInRecipe({this.recipe, this.ingredient, this.amountInGrams});
|
|
factory IngredientInRecipe.fromData(
|
|
Map<String, dynamic> data, GeneratedDatabase db,
|
|
{String prefix}) {
|
|
final effectivePrefix = prefix ?? '';
|
|
final intType = db.typeSystem.forDartType<int>();
|
|
return IngredientInRecipe(
|
|
recipe: intType.mapFromDatabaseResponse(data['${effectivePrefix}recipe']),
|
|
ingredient:
|
|
intType.mapFromDatabaseResponse(data['${effectivePrefix}ingredient']),
|
|
amountInGrams:
|
|
intType.mapFromDatabaseResponse(data['${effectivePrefix}amount']),
|
|
);
|
|
}
|
|
factory IngredientInRecipe.fromJson(Map<String, dynamic> json) {
|
|
return IngredientInRecipe(
|
|
recipe: json['recipe'] as int,
|
|
ingredient: json['ingredient'] as int,
|
|
amountInGrams: json['amountInGrams'] as int,
|
|
);
|
|
}
|
|
Map<String, dynamic> toJson() {
|
|
return {
|
|
'recipe': recipe,
|
|
'ingredient': ingredient,
|
|
'amountInGrams': amountInGrams,
|
|
};
|
|
}
|
|
|
|
IngredientInRecipe copyWith(
|
|
{int recipe, int ingredient, int amountInGrams}) =>
|
|
IngredientInRecipe(
|
|
recipe: recipe ?? this.recipe,
|
|
ingredient: ingredient ?? this.ingredient,
|
|
amountInGrams: amountInGrams ?? this.amountInGrams,
|
|
);
|
|
@override
|
|
String toString() {
|
|
return (StringBuffer('IngredientInRecipe(')
|
|
..write('recipe: $recipe, ')
|
|
..write('ingredient: $ingredient, ')
|
|
..write('amountInGrams: $amountInGrams')
|
|
..write(')'))
|
|
.toString();
|
|
}
|
|
|
|
@override
|
|
int get hashCode => $moorjf($mrjf(
|
|
$mrjf($mrjc(0, recipe.hashCode), ingredient.hashCode),
|
|
amountInGrams.hashCode));
|
|
@override
|
|
bool operator ==(other) =>
|
|
identical(this, other) ||
|
|
(other is IngredientInRecipe &&
|
|
other.recipe == recipe &&
|
|
other.ingredient == ingredient &&
|
|
other.amountInGrams == amountInGrams);
|
|
}
|
|
|
|
class $IngredientInRecipesTable extends IngredientInRecipes
|
|
with TableInfo<$IngredientInRecipesTable, IngredientInRecipe> {
|
|
final GeneratedDatabase _db;
|
|
final String _alias;
|
|
$IngredientInRecipesTable(this._db, [this._alias]);
|
|
GeneratedIntColumn _recipe;
|
|
@override
|
|
GeneratedIntColumn get recipe => _recipe ??= _constructRecipe();
|
|
GeneratedIntColumn _constructRecipe() {
|
|
var cName = 'recipe';
|
|
if (_alias != null) cName = '$_alias.$cName';
|
|
return GeneratedIntColumn(
|
|
'recipe',
|
|
$tableName,
|
|
false,
|
|
);
|
|
}
|
|
|
|
GeneratedIntColumn _ingredient;
|
|
@override
|
|
GeneratedIntColumn get ingredient => _ingredient ??= _constructIngredient();
|
|
GeneratedIntColumn _constructIngredient() {
|
|
var cName = 'ingredient';
|
|
if (_alias != null) cName = '$_alias.$cName';
|
|
return GeneratedIntColumn(
|
|
'ingredient',
|
|
$tableName,
|
|
false,
|
|
);
|
|
}
|
|
|
|
GeneratedIntColumn _amountInGrams;
|
|
@override
|
|
GeneratedIntColumn get amountInGrams =>
|
|
_amountInGrams ??= _constructAmountInGrams();
|
|
GeneratedIntColumn _constructAmountInGrams() {
|
|
var cName = 'amount';
|
|
if (_alias != null) cName = '$_alias.$cName';
|
|
return GeneratedIntColumn(
|
|
'amount',
|
|
$tableName,
|
|
false,
|
|
);
|
|
}
|
|
|
|
@override
|
|
List<GeneratedColumn> get $columns => [recipe, ingredient, amountInGrams];
|
|
@override
|
|
$IngredientInRecipesTable get asDslTable => this;
|
|
@override
|
|
String get $tableName => _alias ?? 'recipe_ingredients';
|
|
@override
|
|
final String actualTableName = 'recipe_ingredients';
|
|
@override
|
|
bool validateIntegrity(IngredientInRecipe instance, bool isInserting) =>
|
|
recipe.isAcceptableValue(instance.recipe, isInserting) &&
|
|
ingredient.isAcceptableValue(instance.ingredient, isInserting) &&
|
|
amountInGrams.isAcceptableValue(instance.amountInGrams, isInserting);
|
|
@override
|
|
Set<GeneratedColumn> get $primaryKey => {recipe, ingredient};
|
|
@override
|
|
IngredientInRecipe map(Map<String, dynamic> data, {String tablePrefix}) {
|
|
final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : null;
|
|
return IngredientInRecipe.fromData(data, _db, prefix: effectivePrefix);
|
|
}
|
|
|
|
@override
|
|
Map<String, Variable> entityToSql(IngredientInRecipe d,
|
|
{bool includeNulls = false}) {
|
|
final map = <String, Variable>{};
|
|
if (d.recipe != null || includeNulls) {
|
|
map['recipe'] = Variable<int, IntType>(d.recipe);
|
|
}
|
|
if (d.ingredient != null || includeNulls) {
|
|
map['ingredient'] = Variable<int, IntType>(d.ingredient);
|
|
}
|
|
if (d.amountInGrams != null || includeNulls) {
|
|
map['amount'] = Variable<int, IntType>(d.amountInGrams);
|
|
}
|
|
return map;
|
|
}
|
|
|
|
@override
|
|
$IngredientInRecipesTable createAlias(String alias) {
|
|
return $IngredientInRecipesTable(_db, alias);
|
|
}
|
|
}
|
|
|
|
abstract class _$Database extends GeneratedDatabase {
|
|
_$Database(QueryExecutor e) : super(const SqlTypeSystem.withDefaults(), e);
|
|
$CategoriesTable _categories;
|
|
$CategoriesTable get categories => _categories ??= $CategoriesTable(this);
|
|
$RecipesTable _recipes;
|
|
$RecipesTable get recipes => _recipes ??= $RecipesTable(this);
|
|
$IngredientsTable _ingredients;
|
|
$IngredientsTable get ingredients => _ingredients ??= $IngredientsTable(this);
|
|
$IngredientInRecipesTable _ingredientInRecipes;
|
|
$IngredientInRecipesTable get ingredientInRecipes =>
|
|
_ingredientInRecipes ??= $IngredientInRecipesTable(this);
|
|
@override
|
|
List<TableInfo> get allTables =>
|
|
[categories, recipes, ingredients, ingredientInRecipes];
|
|
}
|