diff --git a/sqlbuilder/float_expression.go b/sqlbuilder/float_expression.go
index cc18e0b..a3fcb04 100644
--- a/sqlbuilder/float_expression.go
+++ b/sqlbuilder/float_expression.go
@@ -2,6 +2,7 @@ package sqlbuilder
 
 type FloatExpression interface {
 	Expression
+	numericExpression
 
 	EQ(rhs FloatExpression) BoolExpression
 	NOT_EQ(rhs FloatExpression) BoolExpression
@@ -22,6 +23,7 @@ type FloatExpression interface {
 }
 
 type floatInterfaceImpl struct {
+	numericExpressionImpl
 	parent FloatExpression
 }
 
diff --git a/sqlbuilder/func_expression.go b/sqlbuilder/func_expression.go
index 92a65f7..eca8f3f 100644
--- a/sqlbuilder/func_expression.go
+++ b/sqlbuilder/func_expression.go
@@ -186,24 +186,16 @@ func ABSf(floatExpression FloatExpression) FloatExpression {
 	return newFloatFunc("ABS", floatExpression)
 }
 
-func ABSi(integerExpression IntegerExpression) FloatExpression {
-	return newFloatFunc("ABS", integerExpression)
+func ABSi(integerExpression IntegerExpression) IntegerExpression {
+	return newIntegerFunc("ABS", integerExpression)
 }
 
-func SQRTf(floatExpression FloatExpression) FloatExpression {
-	return newFloatFunc("SQRT", floatExpression)
+func SQRT(numericExpression NumericExpression) FloatExpression {
+	return newFloatFunc("SQRT", numericExpression)
 }
 
-func SQRTi(integerExpression IntegerExpression) FloatExpression {
-	return newFloatFunc("SQRT", integerExpression)
-}
-
-func CBRTf(floatExpression FloatExpression) FloatExpression {
-	return newFloatFunc("CBRT", floatExpression)
-}
-
-func CBRTi(integerExpression IntegerExpression) FloatExpression {
-	return newFloatFunc("CBRT", integerExpression)
+func CBRT(numericExpression NumericExpression) FloatExpression {
+	return newFloatFunc("CBRT", numericExpression)
 }
 
 func CEIL(floatExpression FloatExpression) FloatExpression {
@@ -242,12 +234,8 @@ func LOG(floatExpression FloatExpression) FloatExpression {
 
 // ----------------- Aggregate functions  -------------------//
 
-func AVGf(floatExpression FloatExpression) FloatExpression {
-	return newFloatFunc("AVG", floatExpression)
-}
-
-func AVGi(integerExpression IntegerExpression) FloatExpression {
-	return newFloatFunc("AVG", integerExpression)
+func AVG(numericExpression NumericExpression) FloatExpression {
+	return newFloatFunc("AVG", numericExpression)
 }
 
 func BIT_AND(integerExpression IntegerExpression) IntegerExpression {
diff --git a/sqlbuilder/func_expression_test.go b/sqlbuilder/func_expression_test.go
index c0b3cfa..d575f7b 100644
--- a/sqlbuilder/func_expression_test.go
+++ b/sqlbuilder/func_expression_test.go
@@ -6,13 +6,8 @@ import (
 )
 
 func TestFuncAVG(t *testing.T) {
-	t.Run("float", func(t *testing.T) {
-		assertClauseSerialize(t, AVGf(table1ColFloat), "AVG(table1.col_float)")
-	})
-
-	t.Run("integer", func(t *testing.T) {
-		assertClauseSerialize(t, AVGi(table1ColInt), "AVG(table1.col_int)")
-	})
+	assertClauseSerialize(t, AVG(table1ColFloat), "AVG(table1.col_float)")
+	assertClauseSerialize(t, AVG(table1ColInt), "AVG(table1.col_int)")
 }
 
 func TestFuncBIT_AND(t *testing.T) {
@@ -88,27 +83,17 @@ func TestFuncABS(t *testing.T) {
 }
 
 func TestFuncSQRT(t *testing.T) {
-	t.Run("float", func(t *testing.T) {
-		assertClauseSerialize(t, SQRTf(table1ColFloat), "SQRT(table1.col_float)")
-		assertClauseSerialize(t, SQRTf(Float(11.2222)), "SQRT($1)", float64(11.2222))
-	})
-
-	t.Run("integer", func(t *testing.T) {
-		assertClauseSerialize(t, SQRTi(table1ColInt), "SQRT(table1.col_int)")
-		assertClauseSerialize(t, SQRTi(Int(11)), "SQRT($1)", int64(11))
-	})
+	assertClauseSerialize(t, SQRT(table1ColFloat), "SQRT(table1.col_float)")
+	assertClauseSerialize(t, SQRT(Float(11.2222)), "SQRT($1)", float64(11.2222))
+	assertClauseSerialize(t, SQRT(table1ColInt), "SQRT(table1.col_int)")
+	assertClauseSerialize(t, SQRT(Int(11)), "SQRT($1)", int64(11))
 }
 
 func TestFuncCBRT(t *testing.T) {
-	t.Run("float", func(t *testing.T) {
-		assertClauseSerialize(t, CBRTf(table1ColFloat), "CBRT(table1.col_float)")
-		assertClauseSerialize(t, CBRTf(Float(11.2222)), "CBRT($1)", float64(11.2222))
-	})
-
-	t.Run("integer", func(t *testing.T) {
-		assertClauseSerialize(t, CBRTi(table1ColInt), "CBRT(table1.col_int)")
-		assertClauseSerialize(t, CBRTi(Int(11)), "CBRT($1)", int64(11))
-	})
+	assertClauseSerialize(t, CBRT(table1ColFloat), "CBRT(table1.col_float)")
+	assertClauseSerialize(t, CBRT(Float(11.2222)), "CBRT($1)", float64(11.2222))
+	assertClauseSerialize(t, CBRT(table1ColInt), "CBRT(table1.col_int)")
+	assertClauseSerialize(t, CBRT(Int(11)), "CBRT($1)", int64(11))
 }
 
 func TestFuncCEIL(t *testing.T) {
diff --git a/sqlbuilder/integer_expression.go b/sqlbuilder/integer_expression.go
index a146c72..f1344ca 100644
--- a/sqlbuilder/integer_expression.go
+++ b/sqlbuilder/integer_expression.go
@@ -2,6 +2,7 @@ package sqlbuilder
 
 type IntegerExpression interface {
 	Expression
+	numericExpression
 
 	EQ(rhs IntegerExpression) BoolExpression
 	NOT_EQ(rhs IntegerExpression) BoolExpression
@@ -29,6 +30,7 @@ type IntegerExpression interface {
 }
 
 type integerInterfaceImpl struct {
+	numericExpressionImpl
 	parent IntegerExpression
 }
 
diff --git a/sqlbuilder/numeric_expression.go b/sqlbuilder/numeric_expression.go
new file mode 100644
index 0000000..736f70b
--- /dev/null
+++ b/sqlbuilder/numeric_expression.go
@@ -0,0 +1,14 @@
+package sqlbuilder
+
+type NumericExpression interface {
+	Expression
+	numericExpression
+}
+
+type numericExpression interface {
+	isNumericExpression()
+}
+
+type numericExpressionImpl struct{}
+
+func (n *numericExpressionImpl) isNumericExpression() {}
diff --git a/sqlbuilder/select_statement.go b/sqlbuilder/select_statement.go
index b273d44..c3d067e 100644
--- a/sqlbuilder/select_statement.go
+++ b/sqlbuilder/select_statement.go
@@ -24,10 +24,8 @@ type SelectStatement interface {
 	GROUP_BY(groupByClauses ...groupByClause) SelectStatement
 	HAVING(boolExpression BoolExpression) SelectStatement
 	ORDER_BY(orderByClauses ...OrderByClause) SelectStatement
-
 	LIMIT(limit int64) SelectStatement
 	OFFSET(offset int64) SelectStatement
-
 	FOR(lock SelectLock) SelectStatement
 
 	AsTable(alias string) ExpressionTable
diff --git a/tests/all_types_test.go b/tests/all_types_test.go
index 0f8c05e..de96f75 100644
--- a/tests/all_types_test.go
+++ b/tests/all_types_test.go
@@ -230,8 +230,8 @@ func TestFloatOperators(t *testing.T) {
 		AllTypes.Real.POW(Float(11.22)),
 
 		ABSf(AllTypes.Real),
-		SQRTf(AllTypes.Real),
-		CBRTf(AllTypes.Real),
+		SQRT(AllTypes.Real),
+		CBRT(AllTypes.Real),
 		CEIL(AllTypes.Real),
 		FLOOR(AllTypes.Real),
 		ROUND(AllTypes.Decimal),
@@ -284,8 +284,8 @@ func TestIntegerOperators(t *testing.T) {
 		AllTypes.Integer.BIT_SHIFT_RIGHT(Int(11)),
 
 		ABSi(AllTypes.Integer),
-		SQRTi(AllTypes.Integer),
-		CBRTi(AllTypes.Integer),
+		SQRT(AllTypes.Integer),
+		CBRT(AllTypes.Integer),
 	)
 
 	fmt.Println(query.DebugSql())
diff --git a/tests/select_test.go b/tests/select_test.go
index 3b529c9..a534bd8 100644
--- a/tests/select_test.go
+++ b/tests/select_test.go
@@ -854,7 +854,7 @@ ORDER BY SUM(payment.amount) ASC;
 		SELECT(
 			Payment.CustomerID.AS("customer_payment_sum.customer_id"),
 			SUMf(Payment.Amount).AS("customer_payment_sum.amount_sum"),
-			AVGf(Payment.Amount).AS("customer_payment_sum.amount_avg"),
+			AVG(Payment.Amount).AS("customer_payment_sum.amount_avg"),
 			MAXf(Payment.Amount).AS("customer_payment_sum.amount_max"),
 			MINf(Payment.Amount).AS("customer_payment_sum.amount_min"),
 			COUNT(Payment.Amount).AS("customer_payment_sum.amount_count"),