Merge pull request #19405 from netchampfaris/refactor-qb-engine

refactor: qb.engine
2023-01-18 21:17:17 +05:30 · 2023-01-18 21:17:17 +05:30 · fa55793a52
commit fa55793a52
parent fb2c6a5573 ee17b22110
14 changed files with 662 additions and 716 deletions
--- a/frappe/init.py
+++ b/frappe/init.py
@ -23,7 +23,7 @@ import click
 from werkzeug.local import Local, release_local

 from frappe.query_builder import (
-	get_qb_engine,
+	get_query,
 	get_query_builder,
 	patch_query_aggregation,
 	patch_query_execute,
@ -244,7 +244,7 @@ def init(site: str, sites_path: str = ".", new_site: bool = False) -> None:
 	local.session = _dict()
 	local.dev_server = _dev_server
 	local.qb = get_query_builder(local.conf.db_type or "mariadb")
-	local.qb.engine = get_qb_engine()
+	local.qb.get_query = get_query
 	setup_module_map()

 	if not _qb_patched.get(local.conf.db_type):
--- a/frappe/database/database.py
+++ b/frappe/database/database.py
@ -622,7 +622,7 @@ class Database:
 				return [map(values.get, fields)]

 		else:
-			r = frappe.qb.engine.get_query(
+			r = frappe.qb.get_query(
 				"Singles",
 				filters={"field": ("in", tuple(fields)), "doctype": doctype},
 				fields=["field", "value"],
@ -655,7 +655,7 @@ class Database:
 		        # Get coulmn and value of the single doctype Accounts Settings
 		        account_settings = frappe.db.get_singles_dict("Accounts Settings")
 		"""
-		queried_result = frappe.qb.engine.get_query(
+		queried_result = frappe.qb.get_query(
 			"Singles",
 			filters={"doctype": doctype},
 			fields=["field", "value"],
@ -761,7 +761,7 @@ class Database:
 		if cache and fieldname in self.value_cache[doctype]:
 			return self.value_cache[doctype][fieldname]

-		val = frappe.qb.engine.get_query(
+		val = frappe.qb.get_query(
 			table="Singles",
 			filters={"doctype": doctype, "field": fieldname},
 			fields="value",
@ -801,10 +801,10 @@ class Database:
 		distinct=False,
 		limit=None,
 	):
-		query = frappe.qb.engine.get_query(
+		query = frappe.qb.get_query(
 			table=doctype,
 			filters=filters,
-			orderby=order_by,
+			order_by=order_by,
 			for_update=for_update,
 			fields=fields,
 			distinct=distinct,
@ -830,15 +830,14 @@ class Database:
 		as_dict=False,
 	):
 		if names := list(filter(None, names)):
-			return frappe.qb.engine.get_query(
+			return frappe.qb.get_query(
 				doctype,
 				fields=field,
 				filters=names,
 				order_by=order_by,
-				pluck=pluck,
 				distinct=distinct,
 				limit=limit,
-			).run(debug=debug, run=run, as_dict=as_dict)
+			).run(debug=debug, run=run, as_dict=as_dict, pluck=pluck)
 		return {}

 	def set_value(
@ -887,7 +886,7 @@ class Database:
 			field, val, modified=modified, modified_by=modified_by, update_modified=update_modified
 		)

-		query = frappe.qb.engine.build_conditions(table=dt, filters=dn, update=True)
+		query = frappe.qb.get_query(table=dt, filters=dn, update=True)

 		if isinstance(dn, str):
 			frappe.clear_document_cache(dt, dn)
@ -1052,9 +1051,9 @@ class Database:
 			cache_count = frappe.cache().get_value(f"doctype:count:{dt}")
 			if cache_count is not None:
 				return cache_count
-		count = frappe.qb.engine.get_query(
-			table=dt, filters=filters, fields=Count("*"), distinct=distinct
-		).run(debug=debug)[0][0]
+		count = frappe.qb.get_query(table=dt, filters=filters, fields=Count("*"), distinct=distinct).run(
+			debug=debug
+		)[0][0]
 		if not filters and cache:
 			frappe.cache().set_value(f"doctype:count:{dt}", count, expires_in_sec=86400)
 		return count
@ -1195,7 +1194,7 @@ class Database:
 		Doctype name can be passed directly, it will be pre-pended with `tab`.
 		"""
 		filters = filters or kwargs.get("conditions")
-		query = frappe.qb.engine.build_conditions(table=doctype, filters=filters).delete()
+		query = frappe.qb.get_query(table=doctype, filters=filters, delete=True)
 		if "debug" not in kwargs:
 			kwargs["debug"] = debug
 		return query.run(**kwargs)
--- a/frappe/database/operator_map.py
+++ b/frappe/database/operator_map.py
@ -0,0 +1,138 @@
+# Copyright (c) 2023, Frappe Technologies Pvt. Ltd. and Contributors
+# MIT License. See license.txt
+
+import operator
+from typing import Callable
+
+import frappe
+from frappe.database.utils import NestedSetHierarchy
+from frappe.model.db_query import get_timespan_date_range
+from frappe.query_builder import Field
+
+
+def like(key: Field, value: str) -> frappe.qb:
+	"""Wrapper method for `LIKE`
+
+	Args:
+	        key (str): field
+	        value (str): criterion
+
+	Returns:
+	        frappe.qb: `frappe.qb object with `LIKE`
+	"""
+	return key.like(value)
+
+
+def func_in(key: Field, value: list | tuple) -> frappe.qb:
+	"""Wrapper method for `IN`
+
+	Args:
+	        key (str): field
+	        value (Union[int, str]): criterion
+
+	Returns:
+	        frappe.qb: `frappe.qb object with `IN`
+	"""
+	if isinstance(value, str):
+		value = value.split(",")
+	return key.isin(value)
+
+
+def not_like(key: Field, value: str) -> frappe.qb:
+	"""Wrapper method for `NOT LIKE`
+
+	Args:
+	        key (str): field
+	        value (str): criterion
+
+	Returns:
+	        frappe.qb: `frappe.qb object with `NOT LIKE`
+	"""
+	return key.not_like(value)
+
+
+def func_not_in(key: Field, value: list | tuple | str):
+	"""Wrapper method for `NOT IN`
+
+	Args:
+	        key (str): field
+	        value (Union[int, str]): criterion
+
+	Returns:
+	        frappe.qb: `frappe.qb object with `NOT IN`
+	"""
+	if isinstance(value, str):
+		value = value.split(",")
+	return key.notin(value)
+
+
+def func_regex(key: Field, value: str) -> frappe.qb:
+	"""Wrapper method for `REGEX`
+
+	Args:
+	        key (str): field
+	        value (str): criterion
+
+	Returns:
+	        frappe.qb: `frappe.qb object with `REGEX`
+	"""
+	return key.regex(value)
+
+
+def func_between(key: Field, value: list | tuple) -> frappe.qb:
+	"""Wrapper method for `BETWEEN`
+
+	Args:
+	        key (str): field
+	        value (Union[int, str]): criterion
+
+	Returns:
+	        frappe.qb: `frappe.qb object with `BETWEEN`
+	"""
+	return key[slice(*value)]
+
+
+def func_is(key, value):
+	"Wrapper for IS"
+	return key.isnotnull() if value.lower() == "set" else key.isnull()
+
+
+def func_timespan(key: Field, value: str) -> frappe.qb:
+	"""Wrapper method for `TIMESPAN`
+
+	Args:
+	        key (str): field
+	        value (str): criterion
+
+	Returns:
+	        frappe.qb: `frappe.qb object with `TIMESPAN`
+	"""
+
+	return func_between(key, get_timespan_date_range(value))
+
+
+# default operators
+OPERATOR_MAP: dict[str, Callable] = {
+	"+": operator.add,
+	"=": operator.eq,
+	"-": operator.sub,
+	"!=": operator.ne,
+	"<": operator.lt,
+	">": operator.gt,
+	"<=": operator.le,
+	"=<": operator.le,
+	">=": operator.ge,
+	"=>": operator.ge,
+	"/": operator.truediv,
+	"*": operator.mul,
+	"in": func_in,
+	"not in": func_not_in,
+	"like": like,
+	"not like": not_like,
+	"regex": func_regex,
+	"between": func_between,
+	"is": func_is,
+	"timespan": func_timespan,
+	"nested_set": NestedSetHierarchy,
+	# TODO: Add support for custom operators (WIP) - via filters_config hooks
+}
--- a/frappe/database/query.py
+++ b/frappe/database/query.py
--- a/frappe/database/utils.py
+++ b/frappe/database/utils.py
@ -34,6 +34,14 @@ def is_pypika_function_object(field: str) -> bool:
 	return getattr(field, "__module__", None) == "pypika.functions" or isinstance(field, Function)


+def get_doctype_name(table_name: str) -> str:
+	if table_name.startswith(("tab", "`tab", '"tab')):
+		table_name = table_name.replace("tab", "", 1)
+	table_name = table_name.replace("`", "")
+	table_name = table_name.replace('"', "")
+	return table_name
+
+
 class LazyString:
 	def _setup(self) -> None:
 		raise NotImplementedError
--- a/frappe/desk/doctype/number_card/number_card.py
+++ b/frappe/desk/doctype/number_card/number_card.py
@ -200,7 +200,7 @@ def get_cards_for_user(doctype, txt, searchfield, start, page_len, filters):
 	if txt:
 		search_conditions = [numberCard[field].like(f"%{txt}%") for field in searchfields]

-	condition_query = frappe.qb.engine.build_conditions(doctype, filters)
+	condition_query = frappe.qb.get_query(doctype, filters=filters)

 	return (
 		condition_query.select(numberCard.name, numberCard.label, numberCard.document_type)
--- a/frappe/desk/listview.py
+++ b/frappe/desk/listview.py
@ -36,7 +36,7 @@ def get_group_by_count(doctype: str, current_filters: str, field: str) -> list[d
 		ToDo = DocType("ToDo")
 		User = DocType("User")
 		count = Count("*").as_("count")
-		filtered_records = frappe.qb.engine.build_conditions(doctype, current_filters).select("name")
+		filtered_records = frappe.qb.get_query(doctype, filters=current_filters, fields=["name"])

 		return (
 			frappe.qb.from_(ToDo)
--- a/frappe/query_builder/init.py
+++ b/frappe/query_builder/init.py
@ -7,7 +7,7 @@ from frappe.query_builder.terms import ParameterizedFunction, ParameterizedValue
 from frappe.query_builder.utils import (
 	Column,
 	DocType,
-	get_qb_engine,
+	get_query,
 	get_query_builder,
 	patch_query_aggregation,
 	patch_query_execute,
--- a/frappe/query_builder/functions.py
+++ b/frappe/query_builder/functions.py
@ -119,9 +119,9 @@ class Cast_(Function):

 def _aggregate(function, dt, fieldname, filters, **kwargs):
 	return (
-		frappe.qb.engine.build_conditions(dt, filters)
-		.select(function(PseudoColumn(fieldname)))
-		.run(**kwargs)[0][0]
+		frappe.qb.get_query(dt, filters=filters, fields=[function(PseudoColumn(fieldname))]).run(
+			**kwargs
+		)[0][0]
 		or 0
 	)

--- a/frappe/query_builder/utils.py
+++ b/frappe/query_builder/utils.py
@ -2,8 +2,7 @@ from enum import Enum
 from importlib import import_module
 from typing import Any, Callable, get_type_hints

-from pypika import Query
-from pypika.queries import Column
+from pypika.queries import Column, QueryBuilder
 from pypika.terms import PseudoColumn

 import frappe
@ -55,10 +54,10 @@ def get_query_builder(type_of_db: str) -> Postgres | MariaDB:
 	return picks[db]


-def get_qb_engine():
+def get_query(*args, **kwargs) -> QueryBuilder:
 	from frappe.database.query import Engine

-	return Engine()
+	return Engine().get_query(*args, **kwargs)


 def get_attr(method_string):
--- a/frappe/tests/test_db.py
+++ b/frappe/tests/test_db.py
@ -545,7 +545,7 @@ class TestDB(FrappeTestCase):
 		self.assertEqual((frappe.db.count("Note")), 2)

 		# simple filters
-		self.assertEqual((frappe.db.count("Note", ["title", "=", "note1"])), 1)
+		self.assertEqual((frappe.db.count("Note", [["title", "=", "note1"]])), 1)

 		frappe.get_doc(doctype="Note", title="note3", content="something other").insert()

--- a/frappe/tests/test_db_query.py
+++ b/frappe/tests/test_db_query.py
@ -229,9 +229,7 @@ class TestReportview(FrappeTestCase):
 			)

 	def test_none_filter(self):
-		query = frappe.qb.engine.get_query(
-			"DocType", fields="name", filters={"restrict_to_domain": None}
-		)
+		query = frappe.qb.get_query("DocType", fields="name", filters={"restrict_to_domain": None})
 		sql = str(query).replace("`", "").replace('"', "")
 		condition = "restrict_to_domain IS NULL"
 		self.assertIn(condition, sql)
--- a/frappe/tests/test_query.py
+++ b/frappe/tests/test_query.py
@ -56,30 +56,28 @@ class TestQuery(FrappeTestCase):
 	@run_only_if(db_type_is.MARIADB)
 	def test_multiple_tables_in_filters(self):
 		self.assertEqual(
-			frappe.qb.engine.get_query(
+			frappe.qb.get_query(
 				"DocType",
 				["*"],
 				[
-					["BOM Update Log", "name", "like", "f%"],
+					["DocField", "name", "like", "f%"],
 					["DocType", "parent", "=", "something"],
 				],
 			).get_sql(),
-			"SELECT * FROM `tabDocType` LEFT JOIN `tabBOM Update Log` ON `tabBOM Update Log`.`parent`=`tabDocType`.`name` AND `tabBOM Update Log`.`parenttype`='DocType' WHERE `tabBOM Update Log`.`name` LIKE 'f%' AND `tabDocType`.`parent`='something'",
+			"SELECT `tabDocType`.* FROM `tabDocType` LEFT JOIN `tabDocField` ON `tabDocField`.`parent`=`tabDocType`.`name` AND `tabDocField`.`parenttype`='DocType' WHERE `tabDocField`.`name` LIKE 'f%' AND `tabDocType`.`parent`='something'",
 		)

 	@run_only_if(db_type_is.MARIADB)
 	def test_string_fields(self):
 		self.assertEqual(
-			frappe.qb.engine.get_query(
-				"User", fields="name, email", filters={"name": "Administrator"}
-			).get_sql(),
+			frappe.qb.get_query("User", fields="name, email", filters={"name": "Administrator"}).get_sql(),
 			frappe.qb.from_("User")
 			.select(Field("name"), Field("email"))
 			.where(Field("name") == "Administrator")
 			.get_sql(),
 		)
 		self.assertEqual(
-			frappe.qb.engine.get_query(
+			frappe.qb.get_query(
 				"User", fields=["`name`, `email`"], filters={"name": "Administrator"}
 			).get_sql(),
 			frappe.qb.from_("User")
@ -89,7 +87,7 @@ class TestQuery(FrappeTestCase):
 		)

 		self.assertEqual(
-			frappe.qb.engine.get_query(
+			frappe.qb.get_query(
 				"User", fields=["`tabUser`.`name`", "`tabUser`.`email`"], filters={"name": "Administrator"}
 			).run(),
 			frappe.qb.from_("User")
@ -99,7 +97,7 @@ class TestQuery(FrappeTestCase):
 		)

 		self.assertEqual(
-			frappe.qb.engine.get_query(
+			frappe.qb.get_query(
 				"User",
 				fields=["`tabUser`.`name` as owner", "`tabUser`.`email`"],
 				filters={"name": "Administrator"},
@ -111,7 +109,7 @@ class TestQuery(FrappeTestCase):
 		)

 		self.assertEqual(
-			frappe.qb.engine.get_query(
+			frappe.qb.get_query(
 				"User", fields=["`tabUser`.`name`, Count(`name`) as count"], filters={"name": "Administrator"}
 			).run(),
 			frappe.qb.from_("User")
@ -121,7 +119,7 @@ class TestQuery(FrappeTestCase):
 		)

 		self.assertEqual(
-			frappe.qb.engine.get_query(
+			frappe.qb.get_query(
 				"User",
 				fields=["`tabUser`.`name`, Count(`name`) as `count`"],
 				filters={"name": "Administrator"},
@ -133,7 +131,7 @@ class TestQuery(FrappeTestCase):
 		)

 		self.assertEqual(
-			frappe.qb.engine.get_query(
+			frappe.qb.get_query(
 				"User", fields="`tabUser`.`name`, Count(`name`) as `count`", filters={"name": "Administrator"}
 			).run(),
 			frappe.qb.from_("User")
@ -144,38 +142,34 @@ class TestQuery(FrappeTestCase):

 	def test_functions_fields(self):
 		self.assertEqual(
-			frappe.qb.engine.get_query("User", fields="Count(name)", filters={}).get_sql(),
+			frappe.qb.get_query("User", fields="Count(name)", filters={}).get_sql(),
 			frappe.qb.from_("User").select(Count(Field("name"))).get_sql(),
 		)

 		self.assertEqual(
-			frappe.qb.engine.get_query("User", fields=["Count(name)", "Max(name)"], filters={}).get_sql(),
+			frappe.qb.get_query("User", fields=["Count(name)", "Max(name)"], filters={}).get_sql(),
 			frappe.qb.from_("User").select(Count(Field("name")), Max(Field("name"))).get_sql(),
 		)

 		self.assertEqual(
-			frappe.qb.engine.get_query(
-				"User", fields=["abs(name-email)", "Count(name)"], filters={}
-			).get_sql(),
+			frappe.qb.get_query("User", fields=["abs(name-email)", "Count(name)"], filters={}).get_sql(),
 			frappe.qb.from_("User")
 			.select(Abs(Field("name") - Field("email")), Count(Field("name")))
 			.get_sql(),
 		)

 		self.assertEqual(
-			frappe.qb.engine.get_query("User", fields=[Count("*")], filters={}).get_sql(),
+			frappe.qb.get_query("User", fields=[Count("*")], filters={}).get_sql(),
 			frappe.qb.from_("User").select(Count("*")).get_sql(),
 		)

 		self.assertEqual(
-			frappe.qb.engine.get_query(
-				"User", fields="timestamp(creation, modified)", filters={}
-			).get_sql(),
+			frappe.qb.get_query("User", fields="timestamp(creation, modified)", filters={}).get_sql(),
 			frappe.qb.from_("User").select(Timestamp(Field("creation"), Field("modified"))).get_sql(),
 		)

 		self.assertEqual(
-			frappe.qb.engine.get_query(
+			frappe.qb.get_query(
 				"User", fields="Count(name) as count, Max(email) as max_email", filters={}
 			).get_sql(),
 			frappe.qb.from_("User")
@ -186,85 +180,175 @@ class TestQuery(FrappeTestCase):
 	def test_qb_fields(self):
 		user_doctype = frappe.qb.DocType("User")
 		self.assertEqual(
-			frappe.qb.engine.get_query(
+			frappe.qb.get_query(
 				user_doctype, fields=[user_doctype.name, user_doctype.email], filters={}
 			).get_sql(),
 			frappe.qb.from_(user_doctype).select(user_doctype.name, user_doctype.email).get_sql(),
 		)

 		self.assertEqual(
-			frappe.qb.engine.get_query(user_doctype, fields=user_doctype.email, filters={}).get_sql(),
+			frappe.qb.get_query(user_doctype, fields=user_doctype.email, filters={}).get_sql(),
 			frappe.qb.from_(user_doctype).select(user_doctype.email).get_sql(),
 		)

 	def test_aliasing(self):
 		user_doctype = frappe.qb.DocType("User")
 		self.assertEqual(
-			frappe.qb.engine.get_query(
-				user_doctype, fields=["name as owner", "email as id"], filters={}
-			).get_sql(),
+			frappe.qb.get_query("User", fields=["name as owner", "email as id"], filters={}).get_sql(),
 			frappe.qb.from_(user_doctype)
 			.select(user_doctype.name.as_("owner"), user_doctype.email.as_("id"))
 			.get_sql(),
 		)

 		self.assertEqual(
-			frappe.qb.engine.get_query(
-				user_doctype, fields="name as owner, email as id", filters={}
-			).get_sql(),
+			frappe.qb.get_query(user_doctype, fields="name as owner, email as id", filters={}).get_sql(),
 			frappe.qb.from_(user_doctype)
 			.select(user_doctype.name.as_("owner"), user_doctype.email.as_("id"))
 			.get_sql(),
 		)

 		self.assertEqual(
-			frappe.qb.engine.get_query(
+			frappe.qb.get_query(
 				user_doctype, fields=["Count(name) as count", "email as id"], filters={}
 			).get_sql(),
 			frappe.qb.from_(user_doctype)
-			.select(user_doctype.email.as_("id"), Count(Field("name")).as_("count"))
+			.select(Count(Field("name")).as_("count"), user_doctype.email.as_("id"))
 			.get_sql(),
 		)

 	@run_only_if(db_type_is.MARIADB)
 	def test_filters(self):
 		self.assertEqual(
-			frappe.qb.engine.get_query(
+			frappe.qb.get_query(
 				"User", filters={"IfNull(name, " ")": ("<", Now())}, fields=["Max(name)"]
 			).run(),
 			frappe.qb.from_("User").select(Max(Field("name"))).where(Ifnull("name", "") < Now()).run(),
 		)

-	def test_implicit_join_query(self):
 		self.assertEqual(
-			frappe.qb.engine.get_query(
+			frappe.qb.get_query(
+				"DocType",
+				fields=["name"],
+				filters={"module.app_name": "frappe"},
+			).get_sql(),
+			"SELECT `tabDocType`.`name` FROM `tabDocType` LEFT JOIN `tabModule Def` ON `tabModule Def`.`name`=`tabDocType`.`module` WHERE `tabModule Def`.`app_name`='frappe'".replace(
+				"`", '"' if frappe.db.db_type == "postgres" else "`"
+			),
+		)
+
+		self.assertEqual(
+			frappe.qb.get_query(
+				"DocType",
+				fields=["name"],
+				filters={"module.app_name": ("like", "frap%")},
+			).get_sql(),
+			"SELECT `tabDocType`.`name` FROM `tabDocType` LEFT JOIN `tabModule Def` ON `tabModule Def`.`name`=`tabDocType`.`module` WHERE `tabModule Def`.`app_name` LIKE 'frap%'".replace(
+				"`", '"' if frappe.db.db_type == "postgres" else "`"
+			),
+		)
+
+		self.assertEqual(
+			frappe.qb.get_query(
+				"DocType",
+				fields=["name"],
+				filters={"permissions.role": "System Manager"},
+			).get_sql(),
+			"SELECT `tabDocType`.`name` FROM `tabDocType` LEFT JOIN `tabDocPerm` ON `tabDocPerm`.`parent`=`tabDocType`.`name` AND `tabDocPerm`.`parenttype`='DocType' WHERE `tabDocPerm`.`role`='System Manager'".replace(
+				"`", '"' if frappe.db.db_type == "postgres" else "`"
+			),
+		)
+
+		self.assertEqual(
+			frappe.qb.get_query(
+				"DocType",
+				fields=["module"],
+				filters="",
+			).get_sql(),
+			"SELECT `module` FROM `tabDocType` WHERE `name`=''".replace(
+				"`", '"' if frappe.db.db_type == "postgres" else "`"
+			),
+		)
+
+		self.assertEqual(
+			frappe.qb.get_query(
+				"DocType",
+				filters=["ToDo", "Note"],
+			).get_sql(),
+			"SELECT `name` FROM `tabDocType` WHERE `name` IN ('ToDo','Note')".replace(
+				"`", '"' if frappe.db.db_type == "postgres" else "`"
+			),
+		)
+
+		self.assertEqual(
+			frappe.qb.get_query(
+				"DocType",
+				filters={"name": ("in", [])},
+			).get_sql(),
+			"SELECT `name` FROM `tabDocType` WHERE `name` IN ('')".replace(
+				"`", '"' if frappe.db.db_type == "postgres" else "`"
+			),
+		)
+
+		self.assertEqual(
+			frappe.qb.get_query(
+				"DocType",
+				filters=[1, 2, 3],
+			).get_sql(),
+			"SELECT `name` FROM `tabDocType` WHERE `name` IN (1,2,3)".replace(
+				"`", '"' if frappe.db.db_type == "postgres" else "`"
+			),
+		)
+
+		self.assertEqual(
+			frappe.qb.get_query(
+				"DocType",
+				filters=[],
+			).get_sql(),
+			"SELECT `name` FROM `tabDocType`".replace("`", '"' if frappe.db.db_type == "postgres" else "`"),
+		)
+
+	def test_implicit_join_query(self):
+		self.maxDiff = None
+
+		self.assertEqual(
+			frappe.qb.get_query(
 				"Note",
 				filters={"name": "Test Note Title"},
 				fields=["name", "`tabNote Seen By`.`user` as seen_by"],
 			).get_sql(),
-			"SELECT `tabNote`.`name`,`tabNote Seen By`.`user` seen_by FROM `tabNote` LEFT JOIN `tabNote Seen By` ON `tabNote Seen By`.`parent`=`tabNote`.`name` AND `tabNote Seen By`.`parenttype`='Note' WHERE `tabNote`.`name`='Test Note Title'".replace(
+			"SELECT `tabNote`.`name`,`tabNote Seen By`.`user` `seen_by` FROM `tabNote` LEFT JOIN `tabNote Seen By` ON `tabNote Seen By`.`parent`=`tabNote`.`name` AND `tabNote Seen By`.`parenttype`='Note' WHERE `tabNote`.`name`='Test Note Title'".replace(
 				"`", '"' if frappe.db.db_type == "postgres" else "`"
 			),
 		)

 		self.assertEqual(
-			frappe.qb.engine.get_query(
+			frappe.qb.get_query(
 				"Note",
 				filters={"name": "Test Note Title"},
 				fields=["name", "`tabNote Seen By`.`user` as seen_by", "`tabNote Seen By`.`idx` as idx"],
 			).get_sql(),
-			"SELECT `tabNote`.`name`,`tabNote Seen By`.`user` seen_by,`tabNote Seen By`.`idx` idx FROM `tabNote` LEFT JOIN `tabNote Seen By` ON `tabNote Seen By`.`parent`=`tabNote`.`name` AND `tabNote Seen By`.`parenttype`='Note' WHERE `tabNote`.`name`='Test Note Title'".replace(
+			"SELECT `tabNote`.`name`,`tabNote Seen By`.`user` `seen_by`,`tabNote Seen By`.`idx` `idx` FROM `tabNote` LEFT JOIN `tabNote Seen By` ON `tabNote Seen By`.`parent`=`tabNote`.`name` AND `tabNote Seen By`.`parenttype`='Note' WHERE `tabNote`.`name`='Test Note Title'".replace(
 				"`", '"' if frappe.db.db_type == "postgres" else "`"
 			),
 		)

 		self.assertEqual(
-			frappe.qb.engine.get_query(
+			frappe.qb.get_query(
 				"Note",
 				filters={"name": "Test Note Title"},
 				fields=["name", "seen_by.user as seen_by", "`tabNote Seen By`.`idx` as idx"],
 			).get_sql(),
-			"SELECT `tabNote`.`name`,`tabNote Seen By`.`user` seen_by,`tabNote Seen By`.`idx` idx FROM `tabNote` LEFT JOIN `tabNote Seen By` ON `tabNote Seen By`.`parent`=`tabNote`.`name` AND `tabNote Seen By`.`parenttype`='Note' WHERE `tabNote`.`name`='Test Note Title'".replace(
+			"SELECT `tabNote`.`name`,`tabNote Seen By`.`user` `seen_by`,`tabNote Seen By`.`idx` `idx` FROM `tabNote` LEFT JOIN `tabNote Seen By` ON `tabNote Seen By`.`parent`=`tabNote`.`name` AND `tabNote Seen By`.`parenttype`='Note' WHERE `tabNote`.`name`='Test Note Title'".replace(
+				"`", '"' if frappe.db.db_type == "postgres" else "`"
+			),
+		)
+
+		self.assertEqual(
+			frappe.qb.get_query(
+				"DocType",
+				fields=["name", "module.app_name as app_name"],
+			).get_sql(),
+			"SELECT `tabDocType`.`name`,`tabModule Def`.`app_name` `app_name` FROM `tabDocType` LEFT JOIN `tabModule Def` ON `tabModule Def`.`name`=`tabDocType`.`module`".replace(
 				"`", '"' if frappe.db.db_type == "postgres" else "`"
 			),
 		)
@ -272,40 +356,40 @@ class TestQuery(FrappeTestCase):
 	@run_only_if(db_type_is.MARIADB)
 	def test_comment_stripping(self):
 		self.assertNotIn(
-			"email", frappe.qb.engine.get_query("User", fields=["name", "#email"], filters={}).get_sql()
+			"email", frappe.qb.get_query("User", fields=["name", "#email"], filters={}).get_sql()
 		)

 	def test_nestedset(self):
 		frappe.db.sql("delete from `tabDocType` where `name` = 'Test Tree DocType'")
 		frappe.db.sql_ddl("drop table if exists `tabTest Tree DocType`")
 		create_tree_docs()
-		descendants_result = frappe.qb.engine.get_query(
+		descendants_result = frappe.qb.get_query(
 			"Test Tree DocType",
 			fields=["name"],
 			filters={"name": ("descendants of", "Parent 1")},
-			orderby="modified",
+			order_by="modified desc",
 		).run(as_list=1)

 		# Format decendants result
 		descendants_result = list(itertools.chain.from_iterable(descendants_result))
 		self.assertListEqual(descendants_result, get_descendants_of("Test Tree DocType", "Parent 1"))

-		ancestors_result = frappe.qb.engine.get_query(
+		ancestors_result = frappe.qb.get_query(
 			"Test Tree DocType",
 			fields=["name"],
 			filters={"name": ("ancestors of", "Child 2")},
-			orderby="modified",
+			order_by="modified desc",
 		).run(as_list=1)

 		# Format ancestors result
 		ancestors_result = list(itertools.chain.from_iterable(ancestors_result))
 		self.assertListEqual(ancestors_result, get_ancestors_of("Test Tree DocType", "Child 2"))

-		not_descendants_result = frappe.qb.engine.get_query(
+		not_descendants_result = frappe.qb.get_query(
 			"Test Tree DocType",
 			fields=["name"],
 			filters={"name": ("not descendants of", "Parent 1")},
-			orderby="modified",
+			order_by="modified desc",
 		).run(as_dict=1)

 		self.assertListEqual(
@ -317,11 +401,11 @@ class TestQuery(FrappeTestCase):
 			),
 		)

-		not_ancestors_result = frappe.qb.engine.get_query(
+		not_ancestors_result = frappe.qb.get_query(
 			"Test Tree DocType",
 			fields=["name"],
 			filters={"name": ("not ancestors of", "Child 2")},
-			orderby="modified",
+			order_by="modified desc",
 		).run(as_dict=1)

 		self.assertListEqual(
--- a/frappe/utils/goal.py
+++ b/frappe/utils/goal.py
@ -24,10 +24,13 @@ def get_monthly_results(
 	date_format = "%m-%Y" if frappe.db.db_type != "postgres" else "MM-YYYY"

 	return dict(
-		frappe.qb.engine.build_conditions(table=goal_doctype, filters=filters)
-		.select(
-			DateFormat(Table[date_col], date_format).as_("month_year"),
-			Function(aggregation, goal_field),
+		frappe.qb.get_query(
+			table=goal_doctype,
+			fields=[
+				DateFormat(Table[date_col], date_format).as_("month_year"),
+				Function(aggregation, goal_field),
+			],
+			filters=filters,
 		)
 		.groupby("month_year")
 		.run()