diff --git a/src/query-builder/function-module.ts b/src/query-builder/function-module.ts
index 190231529..ca0c944c9 100644
--- a/src/query-builder/function-module.ts
+++ b/src/query-builder/function-module.ts
@@ -61,13 +61,13 @@ export class FunctionModule<DB, TB extends keyof DB> {
    *
    * If this is used in a `select` statement the type of the selected expression
    * will be `number | string` by default. This is because Kysely can't know the
-   * type the db driver outputs. Sometimes the output can be larger than the
-   * largest javascript number and a string is returned instead. Most drivers
-   * allow you to configure the output type of large numbers and Kysely can't
-   * know if you've done so.
+   * type the db driver outputs. Sometimes the output can be larger than the largest
+   * javascript number and a string is returned instead. Most drivers allow you
+   * to configure the output type of large numbers and Kysely can't know if you've
+   * done so.
    *
-   * You can specify the output type of the expression by providing
-   * the type as the first type argument:
+   * You can specify the output type of the expression by providing the type as
+   * the first type argument:
    *
    * ```ts
    * const { avg } = db.fn
@@ -76,9 +76,22 @@ export class FunctionModule<DB, TB extends keyof DB> {
    *   .select(avg<number>('price').as('avg_price'))
    *   .execute()
    * ```
+   *
+   * Sometimes a null is returned, e.g. when row count is 0, and no `group by`
+   * was used. It is highly recommended to include null in the output type union
+   * and handle null values in post-execute code, or wrap the function with a `coalesce`
+   * function.
+   *
+   * ```ts
+   * const { avg } = db.fn
+   *
+   * db.selectFrom('toy')
+   *   .select(avg<number | null>('price').as('avg_price'))
+   *   .execute()
+   * ```
    */
   avg<
-    O extends number | string,
+    O extends number | string | null = number | string,
     C extends SimpleReferenceExpression<DB, TB> = SimpleReferenceExpression<
       DB,
       TB
@@ -143,11 +156,11 @@ export class FunctionModule<DB, TB extends keyof DB> {
    * Calls the `count` function for the column given as the argument.
    *
    * If this is used in a `select` statement the type of the selected expression
-   * will be `number | string | bigint` by default. This is because Kysely can't
-   * know the type the db driver outputs. Sometimes the output can be larger than
-   * the largest javascript number and a string is returned instead. Most drivers
-   * allow you to configure the output type of large numbers and Kysely can't
-   * know if you've done so.
+   * will be `number | string | bigint` by default. This is because Kysely
+   * can't know the type the db driver outputs. Sometimes the output can be larger
+   * than the largest javascript number and a string is returned instead. Most
+   * drivers allow you to configure the output type of large numbers and Kysely
+   * can't know if you've done so.
    *
    * You can specify the output type of the expression by providing
    * the type as the first type argument:
@@ -186,6 +199,9 @@ export class FunctionModule<DB, TB extends keyof DB> {
   /**
    * Calls the `max` function for the column given as the argument.
    *
+   * If this is used in a `select` statement the type of the selected expression
+   * will be the referenced column's type.
+   *
    * ### Examples
    *
    * ```ts
@@ -195,16 +211,30 @@ export class FunctionModule<DB, TB extends keyof DB> {
    *   .select(max('price').as('max_price'))
    *   .execute()
    * ```
+   *
+   * Sometimes a null is returned, e.g. when row count is 0, and no `group by`
+   * was used. It is highly recommended to include null in the output type union
+   * and handle null values in post-execute code, or wrap the function with a `coalesce`
+   * function.
+   *
+   * ```ts
+   * const { max } = db.fn
+   *
+   * db.selectFrom('toy')
+   *   .select(max<number | null, 'price'>('price').as('max_price'))
+   *   .execute()
+   * ```
    */
   max<
-    O extends number | string | bigint,
-    C extends SimpleReferenceExpression<DB, TB> = DynamicReferenceBuilder<any>
+    O extends number | string | bigint | null = number | string | bigint,
+    C extends SimpleReferenceExpression<DB, TB> = DynamicReferenceBuilder
   >(
     column: C
   ): AggregateFunctionBuilder<
     DB,
     TB,
-    ExtractTypeFromReferenceExpression<DB, TB, C, O>
+    | ExtractTypeFromReferenceExpression<DB, TB, C, O>
+    | (null extends O ? null : never)
   > {
     return new AggregateFunctionBuilder({
       aggregateFunctionNode: AggregateFunctionNode.create(
@@ -217,6 +247,9 @@ export class FunctionModule<DB, TB extends keyof DB> {
   /**
    * Calls the `min` function for the column given as the argument.
    *
+   * If this is used in a `select` statement the type of the selected expression
+   * will be the referenced column's type.
+   *
    * ### Examples
    *
    * ```ts
@@ -227,16 +260,29 @@ export class FunctionModule<DB, TB extends keyof DB> {
    *   .execute()
    * ```
    *
+   * Sometimes a null is returned, e.g. when row count is 0, and no `group by`
+   * was used. It is highly recommended to include null in the output type union
+   * and handle null values in post-execute code, or wrap the function with a `coalesce`
+   * function.
+   *
+   * ```ts
+   * const { min } = db.fn
+   *
+   * db.selectFrom('toy')
+   *   .select(min<number | null, 'price'>('price').as('min_price'))
+   *   .execute()
+   * ```
    */
   min<
-    O extends number | string | bigint,
-    C extends SimpleReferenceExpression<DB, TB> = DynamicReferenceBuilder<any>
+    O extends number | string | bigint | null = number | string | bigint,
+    C extends SimpleReferenceExpression<DB, TB> = DynamicReferenceBuilder
   >(
     column: C
   ): AggregateFunctionBuilder<
     DB,
     TB,
-    ExtractTypeFromReferenceExpression<DB, TB, C, O>
+    | ExtractTypeFromReferenceExpression<DB, TB, C, O>
+    | (null extends O ? null : never)
   > {
     return new AggregateFunctionBuilder({
       aggregateFunctionNode: AggregateFunctionNode.create(
@@ -250,11 +296,11 @@ export class FunctionModule<DB, TB extends keyof DB> {
    * Calls the `sum` function for the column given as the argument.
    *
    * If this is used in a `select` statement the type of the selected expression
-   * will be `number | string | bigint` by default. This is because Kysely can't
-   * know the type the db driver outputs. Sometimes the output can be larger than
-   * the largest javascript number and a string is returned instead. Most drivers
-   * allow you to configure the output type of large numbers and Kysely can't
-   * know if you've done so.
+   * will be `number | string | bigint` by default. This is because Kysely
+   * can't know the type the db driver outputs. Sometimes the output can be larger
+   * than the largest javascript number and a string is returned instead. Most
+   * drivers allow you to configure the output type of large numbers and Kysely
+   * can't know if you've done so.
    *
    * You can specify the output type of the expression by providing
    * the type as the first type argument:
@@ -266,9 +312,22 @@ export class FunctionModule<DB, TB extends keyof DB> {
    *   .select(sum<number>('price').as('total_price'))
    *   .execute()
    * ```
+   *
+   * Sometimes a null is returned, e.g. when row count is 0, and no `group by`
+   * was used. It is highly recommended to include null in the output type union
+   * and handle null values in post-execute code, or wrap the function with a `coalesce`
+   * function.
+   *
+   * ```ts
+   * const { sum } = db.fn
+   *
+   * db.selectFrom('toy')
+   *   .select(sum<number | null>('price').as('total_price'))
+   *   .execute()
+   * ```
    */
   sum<
-    O extends number | string | bigint,
+    O extends number | string | bigint | null = number | string | bigint,
     C extends SimpleReferenceExpression<DB, TB> = SimpleReferenceExpression<
       DB,
       TB
diff --git a/test/typings/test-d/coalesce.test-d.ts b/test/typings/test-d/coalesce.test-d.ts
index 14b77833b..5fcc3f1ec 100644
--- a/test/typings/test-d/coalesce.test-d.ts
+++ b/test/typings/test-d/coalesce.test-d.ts
@@ -90,6 +90,18 @@ async function testCoalesceMultiple(db: Kysely<Database>) {
     .groupBy(['last_name', 'first_name', 'age'])
     .execute()
   expectType<{ field: string }>(r2)
+
+  // string | null, string -> string
+  const [r3] = await db
+    .selectFrom('person')
+    .select(
+      coalesce(
+        db.fn.max<string | null, 'first_name'>('first_name'),
+        sql<string>`${sql.literal('N/A')}`
+      ).as('max_first_name')
+    )
+    .execute()
+  expectType<{ max_first_name: string }>(r3)
 }
 
 function value<V>(value: V): RawBuilder<V> {
diff --git a/test/typings/test-d/function-module.test-d.ts b/test/typings/test-d/function-module.test-d.ts
index c3395f198..6dc92f900 100644
--- a/test/typings/test-d/function-module.test-d.ts
+++ b/test/typings/test-d/function-module.test-d.ts
@@ -54,10 +54,15 @@ async function testSelectWithDefaultGenerics(db: Kysely<Database>) {
     .executeTakeFirstOrThrow()
 
   expectAssignable<string | number>(result.avg_age)
+  expectNotAssignable<null>(result.avg_age)
   expectAssignable<string | number | bigint>(result.total_people)
+  expectNotAssignable<null>(result.total_people)
   expectAssignable<number>(result.max_age)
+  expectNotAssignable<string | bigint | null>(result.max_age)
   expectAssignable<number>(result.min_age)
+  expectNotAssignable<string | bigint | null>(result.min_age)
   expectAssignable<string | number | bigint>(result.total_age)
+  expectNotAssignable<null>(result.total_age)
 }
 
 async function testSelectWithCustomGenerics(db: Kysely<Database>) {
@@ -66,22 +71,54 @@ async function testSelectWithCustomGenerics(db: Kysely<Database>) {
   const result = await db
     .selectFrom('person')
     .select(avg<number>('age').as('avg_age'))
+    .select(avg<number | null>('age').as('nullable_avg_age'))
     .select(count<number>('age').as('total_people'))
-    .select(max('age').as('max_age'))
-    .select(min('age').as('min_age'))
+    .select(max<number | null, 'age'>('age').as('nullable_max_age'))
+    .select(max<string, 'age'>('age').as('lying_max_age'))
+    .select(max<string | null, 'age'>('age').as('nullable_lying_max_age'))
+    .select(min<number | null, 'age'>('age').as('nullable_min_age'))
+    .select(min<bigint, 'age'>('age').as('lying_min_age'))
+    .select(min<bigint | null, 'age'>('age').as('nullable_lying_min_age'))
     .select(sum<number>('age').as('total_age'))
+    .select(sum<number | null>('age').as('nullable_total_age'))
     .executeTakeFirstOrThrow()
 
   expectAssignable<number>(result.avg_age)
-  expectNotAssignable<string | bigint>(result.avg_age)
+  expectNotAssignable<string | bigint | null>(result.avg_age)
+  expectAssignable<number | null>(result.nullable_avg_age)
+  expectNotAssignable<string | bigint>(result.nullable_avg_age)
   expectAssignable<number>(result.total_people)
-  expectNotAssignable<string | bigint>(result.total_people)
-  expectAssignable<number>(result.max_age)
-  expectNotAssignable<string | bigint>(result.max_age)
-  expectAssignable<number>(result.min_age)
-  expectNotAssignable<string | bigint>(result.min_age)
+  expectNotAssignable<string | bigint | null>(result.total_people)
+  expectAssignable<number | null>(result.nullable_max_age)
+  expectNotAssignable<string | bigint>(result.nullable_max_age)
+  expectAssignable<number>(result.lying_max_age)
+  expectNotAssignable<string | bigint | null>(result.lying_max_age)
+  expectAssignable<number | null>(result.nullable_lying_max_age)
+  expectNotAssignable<string | bigint>(result.nullable_lying_max_age)
+  expectAssignable<number | null>(result.nullable_min_age)
+  expectNotAssignable<string | bigint>(result.nullable_min_age)
+  expectAssignable<number>(result.lying_min_age)
+  expectNotAssignable<string | bigint | null>(result.lying_min_age)
+  expectAssignable<number | null>(result.nullable_lying_min_age)
+  expectNotAssignable<string | bigint>(result.nullable_lying_min_age)
   expectAssignable<number>(result.total_age)
-  expectNotAssignable<string | bigint>(result.total_age)
+  expectNotAssignable<string | bigint | null>(result.total_age)
+  expectAssignable<number | null>(result.nullable_total_age)
+  expectNotAssignable<string | bigint>(result.nullable_total_age)
+
+  expectError(
+    db
+      .selectFrom('person')
+      .select(max<number>('age').as('max_no_reference_generic'))
+      .executeTakeFirstOrThrow()
+  )
+
+  expectError(
+    db
+      .selectFrom('person')
+      .select(min<number>('age').as('min_no_reference_generic'))
+      .executeTakeFirstOrThrow()
+  )
 }
 
 async function testSelectUnexpectedColumn(db: Kysely<Database>) {
@@ -155,32 +192,48 @@ async function testSelectWithDynamicReference(db: Kysely<Database>) {
     .selectFrom('person')
     .select(avg(dynamicReference).as('avg'))
     .select(avg<number>(dynamicReference).as('another_avg'))
+    .select(avg<number | null>(dynamicReference).as('nullable_avg'))
     .select(count(dynamicReference).as('count'))
     .select(count<bigint>(dynamicReference).as('another_count'))
     .select(max(dynamicReference).as('max'))
     .select(max<number>(dynamicReference).as('another_max'))
+    .select(max<number | null>(dynamicReference).as('nullable_max'))
     .select(min(dynamicReference).as('min'))
     .select(min<string>(dynamicReference).as('another_min'))
+    .select(max<string | null>(dynamicReference).as('nullable_min'))
     .select(sum(dynamicReference).as('sum'))
     .select(sum<number>(dynamicReference).as('another_sum'))
+    .select(sum<number | null>(dynamicReference).as('nullable_sum'))
     .executeTakeFirstOrThrow()
 
   expectAssignable<string | number>(result.avg)
-  expectNotAssignable<bigint>(result.avg)
+  expectNotAssignable<bigint | null>(result.avg)
   expectAssignable<number>(result.another_avg)
-  expectNotAssignable<string | bigint>(result.another_avg)
+  expectNotAssignable<string | bigint | null>(result.another_avg)
+  expectAssignable<number | null>(result.nullable_avg)
+  expectNotAssignable<string | bigint>(result.nullable_avg)
   expectAssignable<string | number | bigint>(result.count)
+  expectNotAssignable<null>(result.count)
   expectAssignable<bigint>(result.another_count)
-  expectNotAssignable<string | number>(result.another_count)
+  expectNotAssignable<string | number | null>(result.another_count)
   expectAssignable<string | number | bigint>(result.max)
+  expectNotAssignable<null>(result.max)
   expectAssignable<number>(result.another_max)
   expectNotAssignable<string | bigint>(result.another_max)
+  expectAssignable<number | null>(result.nullable_max)
+  expectNotAssignable<string | bigint>(result.nullable_max)
   expectAssignable<string | number | bigint>(result.min)
+  expectNotAssignable<null>(result.min)
   expectAssignable<string>(result.another_min)
-  expectNotAssignable<number | bigint>(result.another_min)
+  expectNotAssignable<number | bigint | null>(result.another_min)
+  expectAssignable<string | null>(result.nullable_min)
+  expectNotAssignable<number | bigint>(result.nullable_min)
   expectAssignable<string | number | bigint>(result.sum)
+  expectNotAssignable<null>(result.sum)
   expectAssignable<number>(result.another_sum)
-  expectNotAssignable<string | bigint>(result.another_sum)
+  expectNotAssignable<string | bigint | null>(result.another_sum)
+  expectAssignable<number | null>(result.nullable_sum)
+  expectNotAssignable<string | bigint>(result.nullable_sum)
 }
 
 async function testSelectWithDistinct(db: Kysely<Database>) {