diff --git a/sqlbuilder/bool_expression_test.go b/sqlbuilder/bool_expression_test.go
index 63ea06c..8c28200 100644
--- a/sqlbuilder/bool_expression_test.go
+++ b/sqlbuilder/bool_expression_test.go
@@ -7,13 +7,13 @@ import (
 )
 
 func TestBoolExpressionEQ(t *testing.T) {
-	assert.Equal(t, getTestSerialize(t, table1ColBool.EQ(table2ColBool)), "table1.colBool = table2.colBool")
-	assert.Equal(t, getTestSerialize(t, table1ColBool.AND(table2ColBool).EQ(table2ColBool)), "table1.colBool AND table2.colBool = table2.colBool")
+	assert.Equal(t, getTestSerialize(t, table1ColBool.EQ(table2ColBool)), "(table1.colBool = table2.colBool)")
+	assert.Equal(t, getTestSerialize(t, table1ColBool.AND(table2ColBool).EQ(table2ColBool)), "((table1.colBool AND table2.colBool) = table2.colBool)")
 }
 
 func TestBoolExpressionNOT_EQ(t *testing.T) {
-	assert.Equal(t, getTestSerialize(t, table1ColBool.NOT_EQ(table2ColBool)), "table1.colBool != table2.colBool")
-	assert.Equal(t, getTestSerialize(t, table1ColBool.AND(table2ColBool).NOT_EQ(table2ColBool)), "table1.colBool AND table2.colBool != table2.colBool")
+	assert.Equal(t, getTestSerialize(t, table1ColBool.NOT_EQ(table2ColBool)), "(table1.colBool != table2.colBool)")
+	assert.Equal(t, getTestSerialize(t, table1ColBool.AND(table2ColBool).NOT_EQ(table2ColBool)), "((table1.colBool AND table2.colBool) != table2.colBool)")
 }
 
 func TestBoolExpressionIS_TRUE(t *testing.T) {
@@ -48,7 +48,7 @@ func TestBinaryExpression(t *testing.T) {
 
 	assert.NilError(t, err)
 
-	assert.Equal(t, out.buff.String(), "$1 = $2")
+	assert.Equal(t, out.buff.String(), "($1 = $2)")
 	assert.Equal(t, len(out.args), 2)
 
 	t.Run("alias", func(t *testing.T) {
@@ -58,7 +58,7 @@ func TestBinaryExpression(t *testing.T) {
 		err := alias.serializeForProjection(select_statement, &out)
 
 		assert.NilError(t, err)
-		assert.Equal(t, out.buff.String(), `$1 = $2 AS "alias_eq_expression"`)
+		assert.Equal(t, out.buff.String(), `($1 = $2) AS "alias_eq_expression"`)
 	})
 
 	t.Run("and", func(t *testing.T) {
@@ -68,7 +68,7 @@ func TestBinaryExpression(t *testing.T) {
 		err := exp.serialize(select_statement, &out)
 
 		assert.NilError(t, err)
-		assert.Equal(t, out.buff.String(), `($1 = $2 AND $3 = $4)`)
+		assert.Equal(t, out.buff.String(), `(($1 = $2) AND ($3 = $4))`)
 	})
 
 	t.Run("or", func(t *testing.T) {
@@ -78,7 +78,7 @@ func TestBinaryExpression(t *testing.T) {
 		err := exp.serialize(select_statement, &out)
 
 		assert.NilError(t, err)
-		assert.Equal(t, out.buff.String(), `($1 = $2 OR $3 = $4)`)
+		assert.Equal(t, out.buff.String(), `(($1 = $2) OR ($3 = $4))`)
 	})
 }
 
@@ -89,7 +89,7 @@ func TestUnaryExpression(t *testing.T) {
 	err := notExpression.serialize(select_statement, &out)
 
 	assert.NilError(t, err)
-	assert.Equal(t, out.buff.String(), "NOT $1 = $2")
+	assert.Equal(t, out.buff.String(), "NOT ($1 = $2)")
 
 	t.Run("alias", func(t *testing.T) {
 		alias := notExpression.AS("alias_not_expression")
@@ -98,7 +98,7 @@ func TestUnaryExpression(t *testing.T) {
 		err := alias.serializeForProjection(select_statement, &out)
 
 		assert.NilError(t, err)
-		assert.Equal(t, out.buff.String(), `NOT $1 = $2 AS "alias_not_expression"`)
+		assert.Equal(t, out.buff.String(), `NOT ($1 = $2) AS "alias_not_expression"`)
 	})
 
 	t.Run("and", func(t *testing.T) {
@@ -108,7 +108,7 @@ func TestUnaryExpression(t *testing.T) {
 		err := exp.serialize(select_statement, &out)
 
 		assert.NilError(t, err)
-		assert.Equal(t, out.buff.String(), `(NOT $1 = $2 AND $3 = $4)`)
+		assert.Equal(t, out.buff.String(), `(NOT ($1 = $2) AND ($3 = $4))`)
 	})
 }
 
@@ -119,7 +119,7 @@ func TestUnaryIsTrueExpression(t *testing.T) {
 	err := exp.serialize(select_statement, &out)
 
 	assert.NilError(t, err)
-	assert.Equal(t, out.buff.String(), "$1 = $2 IS TRUE")
+	assert.Equal(t, out.buff.String(), "($1 = $2) IS TRUE")
 
 	t.Run("and", func(t *testing.T) {
 		exp := exp.AND(EQ(Literal(4), Literal(5)))
@@ -128,7 +128,7 @@ func TestUnaryIsTrueExpression(t *testing.T) {
 		err := exp.serialize(select_statement, &out)
 
 		assert.NilError(t, err)
-		assert.Equal(t, out.buff.String(), `($1 = $2 IS TRUE AND $3 = $4)`)
+		assert.Equal(t, out.buff.String(), `(($1 = $2) IS TRUE AND ($3 = $4))`)
 	})
 }
 
@@ -170,7 +170,7 @@ func TestIn(t *testing.T) {
 	query := Literal(1.11).IN(table1.SELECT(table1Col1))
 
 	out := queryData{}
-	err := query.serialize(select_statement, &out)
+	err := query.serialize(select_statement, &out, NO_WRAP)
 
 	assert.NilError(t, err)
 	fmt.Println(out.buff.String())
diff --git a/sqlbuilder/clause.go b/sqlbuilder/clause.go
index ebd0856..b15764c 100644
--- a/sqlbuilder/clause.go
+++ b/sqlbuilder/clause.go
@@ -5,8 +5,24 @@ import (
 	"strconv"
 )
 
+type serializeOption int
+
+const (
+	NO_WRAP serializeOption = iota
+)
+
 type clause interface {
-	serialize(statement statementType, out *queryData) error
+	serialize(statement statementType, out *queryData, options ...serializeOption) error
+}
+
+func contains(options []serializeOption, option serializeOption) bool {
+	for _, opt := range options {
+		if opt == option {
+			return true
+		}
+	}
+
+	return false
 }
 
 type queryData struct {
@@ -65,7 +81,7 @@ func (q *queryData) writeWhere(statement statementType, where expression) error
 	q.writeString("WHERE")
 
 	q.increaseIdent()
-	err := where.serialize(statement, q)
+	err := where.serialize(statement, q, NO_WRAP)
 	q.decreaseIdent()
 
 	return err
@@ -98,7 +114,7 @@ func (q *queryData) writeHaving(statement statementType, having expression) erro
 	q.writeString("HAVING")
 
 	q.increaseIdent()
-	err := having.serialize(statement, q)
+	err := having.serialize(statement, q, NO_WRAP)
 	q.decreaseIdent()
 
 	return err
diff --git a/sqlbuilder/column.go b/sqlbuilder/column.go
index 6f2d71b..e8c3dc7 100644
--- a/sqlbuilder/column.go
+++ b/sqlbuilder/column.go
@@ -96,7 +96,7 @@ func (c *baseColumn) serializeAsOrderBy(statement statementType, out *queryData)
 	return c.serialize(statement, out)
 }
 
-func (c baseColumn) serialize(statement statementType, out *queryData) error {
+func (c baseColumn) serialize(statement statementType, out *queryData, options ...serializeOption) error {
 
 	columnRef := ""
 
diff --git a/sqlbuilder/expression.go b/sqlbuilder/expression.go
index faaeefc..09e3d6e 100644
--- a/sqlbuilder/expression.go
+++ b/sqlbuilder/expression.go
@@ -83,21 +83,7 @@ func newBinaryExpression(lhs, rhs expression, operator string, parent ...express
 	return binaryExpression
 }
 
-func isSimpleOperand(expression expression) bool {
-	if _, ok := expression.(*literalExpression); ok {
-		return true
-	}
-	if _, ok := expression.(column); ok {
-		return true
-	}
-	if _, ok := expression.(*floatFunc); ok {
-		return true
-	}
-
-	return false
-}
-
-func (c *binaryOpExpression) serialize(statement statementType, out *queryData) error {
+func (c *binaryOpExpression) serialize(statement statementType, out *queryData, options ...serializeOption) error {
 	if c == nil {
 		return errors.New("Binary expression is nil.")
 	}
@@ -108,7 +94,7 @@ func (c *binaryOpExpression) serialize(statement statementType, out *queryData)
 		return errors.Newf("nil rhs.")
 	}
 
-	wrap := !isSimpleOperand(c.lhs) && !isSimpleOperand(c.rhs)
+	wrap := !contains(options, NO_WRAP)
 
 	if wrap {
 		out.writeString("(")
@@ -146,7 +132,7 @@ func newPrefixExpression(expression expression, operator string) prefixOpExpress
 	return prefixExpression
 }
 
-func (p *prefixOpExpression) serialize(statement statementType, out *queryData) error {
+func (p *prefixOpExpression) serialize(statement statementType, out *queryData, options ...serializeOption) error {
 	if p == nil {
 		return errors.New("Prefix expression is nil.")
 	}
@@ -178,7 +164,7 @@ func newPostfixOpExpression(expression expression, operator string) postfixOpExp
 	return postfixOpExpression
 }
 
-func (p *postfixOpExpression) serialize(statement statementType, out *queryData) error {
+func (p *postfixOpExpression) serialize(statement statementType, out *queryData, options ...serializeOption) error {
 	if p == nil {
 		return errors.New("Postifx operator expression is nil.")
 	}
diff --git a/sqlbuilder/expression_old.go b/sqlbuilder/expression_old.go
index 64f6542..b1bae4f 100644
--- a/sqlbuilder/expression_old.go
+++ b/sqlbuilder/expression_old.go
@@ -14,7 +14,7 @@ type intervalExpression struct {
 
 const intervalSep = ":"
 
-func (c *intervalExpression) serialize(statement statementType, out *queryData) error {
+func (c *intervalExpression) serialize(statement statementType, out *queryData, options ...serializeOption) error {
 	out.writeString("INTERVAL '")
 
 	duration := c.duration
diff --git a/sqlbuilder/expression_table.go b/sqlbuilder/expression_table.go
index ad5d8c5..15484ed 100644
--- a/sqlbuilder/expression_table.go
+++ b/sqlbuilder/expression_table.go
@@ -48,7 +48,7 @@ func (e *expressionTableImpl) RefStringColumn(column column) *StringColumn {
 	return strColumn
 }
 
-func (e *expressionTableImpl) serialize(statement statementType, out *queryData) error {
+func (e *expressionTableImpl) serialize(statement statementType, out *queryData, options ...serializeOption) error {
 	if e == nil {
 		return errors.New("Expression table is nil. ")
 	}
diff --git a/sqlbuilder/expression_test.go b/sqlbuilder/expression_test.go
index f479c0e..f52f762 100644
--- a/sqlbuilder/expression_test.go
+++ b/sqlbuilder/expression_test.go
@@ -7,20 +7,20 @@ import (
 
 func TestExpressionIS_NULL(t *testing.T) {
 	assert.Equal(t, getTestSerialize(t, table2Col3.IS_NULL()), "table2.col3 IS NULL")
-	assert.Equal(t, getTestSerialize(t, table2Col3.ADD(table2Col3).IS_NULL()), "table2.col3 + table2.col3 IS NULL")
+	assert.Equal(t, getTestSerialize(t, table2Col3.ADD(table2Col3).IS_NULL()), "(table2.col3 + table2.col3) IS NULL")
 }
 
 func TestExpressionIS_NOT_NULL(t *testing.T) {
 	assert.Equal(t, getTestSerialize(t, table2Col3.IS_NOT_NULL()), "table2.col3 IS NOT NULL")
-	assert.Equal(t, getTestSerialize(t, table2Col3.ADD(table2Col3).IS_NOT_NULL()), "table2.col3 + table2.col3 IS NOT NULL")
+	assert.Equal(t, getTestSerialize(t, table2Col3.ADD(table2Col3).IS_NOT_NULL()), "(table2.col3 + table2.col3) IS NOT NULL")
 }
 
 func TestExpressionIS_DISTINCT_FROM(t *testing.T) {
-	assert.Equal(t, getTestSerialize(t, table2Col3.IS_DISTINCT_FROM(table2Col4)), "table2.col3 IS DISTINCT FROM table2.col4")
-	assert.Equal(t, getTestSerialize(t, table2Col3.ADD(table2Col3).IS_DISTINCT_FROM(Int(23))), "(table2.col3 + table2.col3 IS DISTINCT FROM $1)")
+	assert.Equal(t, getTestSerialize(t, table2Col3.IS_DISTINCT_FROM(table2Col4)), "(table2.col3 IS DISTINCT FROM table2.col4)")
+	assert.Equal(t, getTestSerialize(t, table2Col3.ADD(table2Col3).IS_DISTINCT_FROM(Int(23))), "((table2.col3 + table2.col3) IS DISTINCT FROM $1)")
 }
 
 func TestExpressionIS_NOT_DISTINCT_FROM(t *testing.T) {
-	assert.Equal(t, getTestSerialize(t, table2Col3.IS_NOT_DISTINCT_FROM(table2Col4)), "table2.col3 IS NOT DISTINCT FROM table2.col4")
-	assert.Equal(t, getTestSerialize(t, table2Col3.ADD(table2Col3).IS_NOT_DISTINCT_FROM(Int(23))), "(table2.col3 + table2.col3 IS NOT DISTINCT FROM $1)")
+	assert.Equal(t, getTestSerialize(t, table2Col3.IS_NOT_DISTINCT_FROM(table2Col4)), "(table2.col3 IS NOT DISTINCT FROM table2.col4)")
+	assert.Equal(t, getTestSerialize(t, table2Col3.ADD(table2Col3).IS_NOT_DISTINCT_FROM(Int(23))), "((table2.col3 + table2.col3) IS NOT DISTINCT FROM $1)")
 }
diff --git a/sqlbuilder/float_expression.go b/sqlbuilder/float_expression.go
index ae5b330..bb19674 100644
--- a/sqlbuilder/float_expression.go
+++ b/sqlbuilder/float_expression.go
@@ -111,7 +111,7 @@ func newFloatExpressionWrap(expression expression) FloatExpression {
 	return &floatExpressionWrap
 }
 
-func (n *floatExpressionWrapper) serialize(statement statementType, out *queryData) error {
+func (n *floatExpressionWrapper) serialize(statement statementType, out *queryData, options ...serializeOption) error {
 	if n == nil {
 		return errors.New("Float expression wrapper is nil. ")
 	}
diff --git a/sqlbuilder/float_expression_test.go b/sqlbuilder/float_expression_test.go
index 8f6fbd0..958c0b4 100644
--- a/sqlbuilder/float_expression_test.go
+++ b/sqlbuilder/float_expression_test.go
@@ -6,33 +6,33 @@ import (
 )
 
 func TestFloatExpressionEQColumn(t *testing.T) {
-	assert.Equal(t, getTestSerialize(t, table1Col1.EQ(table2Col3)), "table1.col1 = table2.col3")
+	assert.Equal(t, getTestSerialize(t, table1Col1.EQ(table2Col3)), "(table1.col1 = table2.col3)")
 }
 
 func TestFloatExpressionEQInt(t *testing.T) {
-	assert.Equal(t, getTestSerialize(t, table1Col1.EQ(Int(11))), "table1.col1 = $1")
+	assert.Equal(t, getTestSerialize(t, table1Col1.EQ(Int(11))), "(table1.col1 = $1)")
 }
 
 func TestFloatExpressionEQFloat(t *testing.T) {
-	assert.Equal(t, getTestSerialize(t, table1Col1.EQ(Int(22))), "table1.col1 = $1")
+	assert.Equal(t, getTestSerialize(t, table1Col1.EQ(Int(22))), "(table1.col1 = $1)")
 }
 
 func TestFloatExpressionNOT_EQ(t *testing.T) {
-	assert.Equal(t, getTestSerialize(t, table1Col1.NOT_EQ(table2Col3)), "table1.col1 != table2.col3")
+	assert.Equal(t, getTestSerialize(t, table1Col1.NOT_EQ(table2Col3)), "(table1.col1 != table2.col3)")
 }
 
 func TestFloatExpressionGT(t *testing.T) {
-	assert.Equal(t, getTestSerialize(t, table1Col1.GT(table2Col3)), "table1.col1 > table2.col3")
+	assert.Equal(t, getTestSerialize(t, table1Col1.GT(table2Col3)), "(table1.col1 > table2.col3)")
 }
 
 func TestFloatExpressionGT_EQ(t *testing.T) {
-	assert.Equal(t, getTestSerialize(t, table1Col1.GT_EQ(table2Col3)), "table1.col1 >= table2.col3")
+	assert.Equal(t, getTestSerialize(t, table1Col1.GT_EQ(table2Col3)), "(table1.col1 >= table2.col3)")
 }
 
 func TestFloatExpressionLT(t *testing.T) {
-	assert.Equal(t, getTestSerialize(t, table1Col1.LT(table2Col3)), "table1.col1 < table2.col3")
+	assert.Equal(t, getTestSerialize(t, table1Col1.LT(table2Col3)), "(table1.col1 < table2.col3)")
 }
 
 func TestFloatExpressionLT_EQ(t *testing.T) {
-	assert.Equal(t, getTestSerialize(t, table1Col1.LT_EQ(table2Col3)), "table1.col1 <= table2.col3")
+	assert.Equal(t, getTestSerialize(t, table1Col1.LT_EQ(table2Col3)), "(table1.col1 <= table2.col3)")
 }
diff --git a/sqlbuilder/func_expression.go b/sqlbuilder/func_expression.go
index 78cf8b2..5d30433 100644
--- a/sqlbuilder/func_expression.go
+++ b/sqlbuilder/func_expression.go
@@ -28,7 +28,7 @@ func newFunc(name string, expressions []expression, parent expression) *funcExpr
 	return funcExp
 }
 
-func (f *funcExpressionImpl) serialize(statement statementType, out *queryData) error {
+func (f *funcExpressionImpl) serialize(statement statementType, out *queryData, options ...serializeOption) error {
 	if f == nil {
 		return errors.New("Function expression is nil. ")
 	}
diff --git a/sqlbuilder/keyword.go b/sqlbuilder/keyword.go
index cdd642a..fb3f8b3 100644
--- a/sqlbuilder/keyword.go
+++ b/sqlbuilder/keyword.go
@@ -6,7 +6,7 @@ const (
 
 type keywordClause string
 
-func (k keywordClause) serialize(statement statementType, out *queryData) error {
+func (k keywordClause) serialize(statement statementType, out *queryData, options ...serializeOption) error {
 	out.writeString(string(k))
 
 	return nil
diff --git a/sqlbuilder/literal_expression.go b/sqlbuilder/literal_expression.go
index d152d02..2121600 100644
--- a/sqlbuilder/literal_expression.go
+++ b/sqlbuilder/literal_expression.go
@@ -15,7 +15,7 @@ func Literal(value interface{}) *literalExpression {
 	return &exp
 }
 
-func (l literalExpression) serialize(statement statementType, out *queryData) error {
+func (l literalExpression) serialize(statement statementType, out *queryData, options ...serializeOption) error {
 	out.insertArgument(l.value)
 
 	return nil
diff --git a/sqlbuilder/operators.go b/sqlbuilder/operators.go
index 631efd0..1e446e3 100644
--- a/sqlbuilder/operators.go
+++ b/sqlbuilder/operators.go
@@ -149,7 +149,7 @@ func (c *caseOperatorImpl) ELSE(els expression) caseOperatorExpression {
 	return c
 }
 
-func (c *caseOperatorImpl) serialize(statement statementType, out *queryData) error {
+func (c *caseOperatorImpl) serialize(statement statementType, out *queryData, options ...serializeOption) error {
 	if c == nil {
 		return errors.New("Case expression is nil. ")
 	}
@@ -174,14 +174,14 @@ func (c *caseOperatorImpl) serialize(statement statementType, out *queryData) er
 
 	for i, when := range c.when {
 		out.writeString("WHEN")
-		err := when.serialize(statement, out)
+		err := when.serialize(statement, out, NO_WRAP)
 
 		if err != nil {
 			return err
 		}
 
 		out.writeString("THEN")
-		err = c.then[i].serialize(statement, out)
+		err = c.then[i].serialize(statement, out, NO_WRAP)
 
 		if err != nil {
 			return err
@@ -190,7 +190,7 @@ func (c *caseOperatorImpl) serialize(statement statementType, out *queryData) er
 
 	if c.els != nil {
 		out.writeString("ELSE")
-		err := c.els.serialize(statement, out)
+		err := c.els.serialize(statement, out, NO_WRAP)
 
 		if err != nil {
 			return err
diff --git a/sqlbuilder/select_statement.go b/sqlbuilder/select_statement.go
index bf9ca81..70d9fe1 100644
--- a/sqlbuilder/select_statement.go
+++ b/sqlbuilder/select_statement.go
@@ -85,7 +85,7 @@ func (s *selectStatementImpl) FROM(table readableTable) selectStatement {
 	return s
 }
 
-func (s *selectStatementImpl) serialize(statement statementType, out *queryData) error {
+func (s *selectStatementImpl) serialize(statement statementType, out *queryData, options ...serializeOption) error {
 	if s == nil {
 		return errors.New("Select statement is nil. ")
 	}
diff --git a/sqlbuilder/set_statement.go b/sqlbuilder/set_statement.go
index 649214b..3191f8c 100644
--- a/sqlbuilder/set_statement.go
+++ b/sqlbuilder/set_statement.go
@@ -98,7 +98,7 @@ func (us *setStatementImpl) AsTable(alias string) expressionTable {
 	}
 }
 
-func (s *setStatementImpl) serialize(statement statementType, out *queryData) error {
+func (s *setStatementImpl) serialize(statement statementType, out *queryData, options ...serializeOption) error {
 	if s == nil {
 		return errors.New("Set statement is nil. ")
 	}
diff --git a/sqlbuilder/string_expression_test.go b/sqlbuilder/string_expression_test.go
index f9d7475..7631d4d 100644
--- a/sqlbuilder/string_expression_test.go
+++ b/sqlbuilder/string_expression_test.go
@@ -12,7 +12,7 @@ func TestStringEQColumn(t *testing.T) {
 	err := exp.serialize(select_statement, &out)
 
 	assert.NilError(t, err)
-	assert.Equal(t, out.buff.String(), "table3.col2 = table2.colStr")
+	assert.Equal(t, out.buff.String(), "(table3.col2 = table2.colStr)")
 }
 
 func TestStringEQString(t *testing.T) {
@@ -22,7 +22,7 @@ func TestStringEQString(t *testing.T) {
 	err := exp.serialize(select_statement, &out)
 
 	assert.NilError(t, err)
-	assert.Equal(t, out.buff.String(), "table3.col2 = $1")
+	assert.Equal(t, out.buff.String(), "(table3.col2 = $1)")
 }
 
 func TestStringNOT_EQ(t *testing.T) {
@@ -32,7 +32,7 @@ func TestStringNOT_EQ(t *testing.T) {
 	err := exp.serialize(select_statement, &out)
 
 	assert.NilError(t, err)
-	assert.Equal(t, out.buff.String(), "table3.col2 != table2.colStr")
+	assert.Equal(t, out.buff.String(), "(table3.col2 != table2.colStr)")
 }
 
 func TestStringGT(t *testing.T) {
@@ -42,7 +42,7 @@ func TestStringGT(t *testing.T) {
 	err := exp.serialize(select_statement, &out)
 
 	assert.NilError(t, err)
-	assert.Equal(t, out.buff.String(), "table3.col2 > table2.colStr")
+	assert.Equal(t, out.buff.String(), "(table3.col2 > table2.colStr)")
 }
 
 func TestStringGT_EQ(t *testing.T) {
@@ -52,7 +52,7 @@ func TestStringGT_EQ(t *testing.T) {
 	err := exp.serialize(select_statement, &out)
 
 	assert.NilError(t, err)
-	assert.Equal(t, out.buff.String(), "table3.col2 >= table2.colStr")
+	assert.Equal(t, out.buff.String(), "(table3.col2 >= table2.colStr)")
 }
 
 func TestStringLT(t *testing.T) {
@@ -62,7 +62,7 @@ func TestStringLT(t *testing.T) {
 	err := exp.serialize(select_statement, &out)
 
 	assert.NilError(t, err)
-	assert.Equal(t, out.buff.String(), "table3.col2 < table2.colStr")
+	assert.Equal(t, out.buff.String(), "(table3.col2 < table2.colStr)")
 }
 
 func TestStringLT_EQ(t *testing.T) {
@@ -72,5 +72,5 @@ func TestStringLT_EQ(t *testing.T) {
 	err := exp.serialize(select_statement, &out)
 
 	assert.NilError(t, err)
-	assert.Equal(t, out.buff.String(), "table3.col2 <= table2.colStr")
+	assert.Equal(t, out.buff.String(), "(table3.col2 <= table2.colStr)")
 }
diff --git a/sqlbuilder/table.go b/sqlbuilder/table.go
index 91d3842..9bc4383 100644
--- a/sqlbuilder/table.go
+++ b/sqlbuilder/table.go
@@ -107,7 +107,7 @@ func (t *Table) Columns() []column {
 
 // Generates the sql string for the current tableName expression.  Note: the
 // generated string may not be a valid/executable sql Statement.
-func (t *Table) serialize(statement statementType, out *queryData) error {
+func (t *Table) serialize(statement statementType, out *queryData, options ...serializeOption) error {
 	if t == nil {
 		return errors.Newf("Table is nil. ")
 	}
@@ -271,7 +271,7 @@ func (t *joinTable) Column(name string) column {
 	}
 }
 
-func (t *joinTable) serialize(statement statementType, out *queryData) (err error) {
+func (t *joinTable) serialize(statement statementType, out *queryData, options ...serializeOption) (err error) {
 	if t == nil {
 		return errors.New("Join table is nil. ")
 	}
diff --git a/sqlbuilder/time_expression_test.go b/sqlbuilder/time_expression_test.go
index 2a35938..0086b49 100644
--- a/sqlbuilder/time_expression_test.go
+++ b/sqlbuilder/time_expression_test.go
@@ -6,31 +6,31 @@ import (
 )
 
 func TestTimeExpressionEQ(t *testing.T) {
-	assert.Equal(t, getTestSerialize(t, table1ColTime.EQ(table2ColTime)), "table1.colTime = table2.colTime")
-	assert.Equal(t, getTestSerialize(t, table1ColTime.EQ(Time(10, 20, 0, 0))), "table1.colTime = $1")
+	assert.Equal(t, getTestSerialize(t, table1ColTime.EQ(table2ColTime)), "(table1.colTime = table2.colTime)")
+	assert.Equal(t, getTestSerialize(t, table1ColTime.EQ(Time(10, 20, 0, 0))), "(table1.colTime = $1)")
 }
 
 func TestTimeExpressionNOT_EQ(t *testing.T) {
-	assert.Equal(t, getTestSerialize(t, table1ColTime.NOT_EQ(table2ColTime)), "table1.colTime != table2.colTime")
-	assert.Equal(t, getTestSerialize(t, table1ColTime.NOT_EQ(Time(10, 20, 0, 0))), "table1.colTime != $1")
+	assert.Equal(t, getTestSerialize(t, table1ColTime.NOT_EQ(table2ColTime)), "(table1.colTime != table2.colTime)")
+	assert.Equal(t, getTestSerialize(t, table1ColTime.NOT_EQ(Time(10, 20, 0, 0))), "(table1.colTime != $1)")
 }
 
 func TestTimeExpressionLT(t *testing.T) {
-	assert.Equal(t, getTestSerialize(t, table1ColTime.LT(table2ColTime)), "table1.colTime < table2.colTime")
-	assert.Equal(t, getTestSerialize(t, table1ColTime.LT(Time(10, 20, 0, 0))), "table1.colTime < $1")
+	assert.Equal(t, getTestSerialize(t, table1ColTime.LT(table2ColTime)), "(table1.colTime < table2.colTime)")
+	assert.Equal(t, getTestSerialize(t, table1ColTime.LT(Time(10, 20, 0, 0))), "(table1.colTime < $1)")
 }
 
 func TestTimeExpressionLT_EQ(t *testing.T) {
-	assert.Equal(t, getTestSerialize(t, table1ColTime.LT_EQ(table2ColTime)), "table1.colTime <= table2.colTime")
-	assert.Equal(t, getTestSerialize(t, table1ColTime.LT_EQ(Time(10, 20, 0, 0))), "table1.colTime <= $1")
+	assert.Equal(t, getTestSerialize(t, table1ColTime.LT_EQ(table2ColTime)), "(table1.colTime <= table2.colTime)")
+	assert.Equal(t, getTestSerialize(t, table1ColTime.LT_EQ(Time(10, 20, 0, 0))), "(table1.colTime <= $1)")
 }
 
 func TestTimeExpressionGT(t *testing.T) {
-	assert.Equal(t, getTestSerialize(t, table1ColTime.GT(table2ColTime)), "table1.colTime > table2.colTime")
-	assert.Equal(t, getTestSerialize(t, table1ColTime.GT(Time(10, 20, 0, 0))), "table1.colTime > $1")
+	assert.Equal(t, getTestSerialize(t, table1ColTime.GT(table2ColTime)), "(table1.colTime > table2.colTime)")
+	assert.Equal(t, getTestSerialize(t, table1ColTime.GT(Time(10, 20, 0, 0))), "(table1.colTime > $1)")
 }
 
 func TestTimeExpressionGT_EQ(t *testing.T) {
-	assert.Equal(t, getTestSerialize(t, table1ColTime.GT_EQ(table2ColTime)), "table1.colTime >= table2.colTime")
-	assert.Equal(t, getTestSerialize(t, table1ColTime.GT_EQ(Time(10, 20, 0, 0))), "table1.colTime >= $1")
+	assert.Equal(t, getTestSerialize(t, table1ColTime.GT_EQ(table2ColTime)), "(table1.colTime >= table2.colTime)")
+	assert.Equal(t, getTestSerialize(t, table1ColTime.GT_EQ(Time(10, 20, 0, 0))), "(table1.colTime >= $1)")
 }
diff --git a/tests/select_test.go b/tests/select_test.go
index 3309ec7..621ef58 100644
--- a/tests/select_test.go
+++ b/tests/select_test.go
@@ -62,7 +62,7 @@ SELECT payment.payment_id AS "payment.payment_id",
      customer.last_update AS "customer.last_update",
      customer.active AS "customer.active"
 FROM dvds.payment
-     JOIN dvds.customer ON payment.customer_id = customer.customer_id
+     JOIN dvds.customer ON (payment.customer_id = customer.customer_id)
 ORDER BY payment.payment_id ASC
 LIMIT 30;
 `
@@ -196,11 +196,11 @@ SELECT film_actor.actor_id AS "film_actor.actor_id",
      rental.staff_id AS "rental.staff_id",
      rental.last_update AS "rental.last_update"
 FROM dvds.film_actor
-     JOIN dvds.actor ON film_actor.actor_id = actor.actor_id
-     JOIN dvds.film ON film_actor.film_id = film.film_id
-     JOIN dvds.language ON film.language_id = language.language_id
-     JOIN dvds.inventory ON inventory.film_id = film.film_id
-     JOIN dvds.rental ON rental.inventory_id = inventory.inventory_id
+     JOIN dvds.actor ON (film_actor.actor_id = actor.actor_id)
+     JOIN dvds.film ON (film_actor.film_id = film.film_id)
+     JOIN dvds.language ON (film.language_id = language.language_id)
+     JOIN dvds.inventory ON (inventory.film_id = film.film_id)
+     JOIN dvds.rental ON (rental.inventory_id = inventory.inventory_id)
 ORDER BY film.film_id ASC
 LIMIT 50;
 `
@@ -271,7 +271,7 @@ SELECT language.language_id AS "language.language_id",
      film.special_features AS "film.special_features",
      film.fulltext AS "film.fulltext"
 FROM dvds.film
-     JOIN dvds.language ON film.language_id = language.language_id
+     JOIN dvds.language ON (film.language_id = language.language_id)
 WHERE film.rating = 'NC-17'
 LIMIT 15;
 `
@@ -413,7 +413,7 @@ SELECT customer.customer_id AS "customer.customer_id",
      address.phone AS "address.phone",
      address.last_update AS "address.last_update"
 FROM dvds.customer
-     FULL JOIN dvds.address ON customer.address_id = address.address_id
+     FULL JOIN dvds.address ON (customer.address_id = address.address_id)
 ORDER BY customer.customer_id ASC;
 `
 	query := Customer.
@@ -500,7 +500,7 @@ SELECT employee.employee_id AS "employee.employee_id",
      manager.last_name AS "manager.last_name",
      manager.manager_id AS "manager.manager_id"
 FROM test_sample.employee
-     LEFT JOIN test_sample.employee AS manager ON manager.employee_id = employee.manager_id
+     LEFT JOIN test_sample.employee AS manager ON (manager.employee_id = employee.manager_id)
 ORDER BY employee.employee_id;
 `
 
@@ -568,7 +568,7 @@ SELECT f1.film_id AS "f1.film_id",
      f2.special_features AS "f2.special_features",
      f2.fulltext AS "f2.fulltext"
 FROM dvds.film AS f1
-     JOIN dvds.film AS f2 ON (f1.film_id < f2.film_id AND f1.length = f2.length)
+     JOIN dvds.film AS f2 ON ((f1.film_id < f2.film_id) AND (f1.length = f2.length))
 ORDER BY f1.film_id ASC;
 `
 	f1 := Film.AS("f1")
@@ -605,7 +605,7 @@ SELECT f1.title AS "thesame_length_films.title1",
      f2.title AS "thesame_length_films.title2",
      f1.length AS "thesame_length_films.length"
 FROM dvds.film AS f1
-     JOIN dvds.film AS f2 ON (f1.film_id != f2.film_id AND f1.length = f2.length)
+     JOIN dvds.film AS f2 ON ((f1.film_id != f2.film_id) AND (f1.length = f2.length))
 ORDER BY f1.length ASC, f1.title ASC, f2.title ASC
 LIMIT 1000;
 `
@@ -731,14 +731,14 @@ SELECT actor.actor_id AS "actor.actor_id",
      films."film.title" AS "film.title",
      films."film.rating" AS "film.rating"
 FROM dvds.actor
-     JOIN dvds.film_actor ON actor.actor_id = film_actor.film_id
+     JOIN dvds.film_actor ON (actor.actor_id = film_actor.film_id)
      JOIN (
           SELECT film.film_id AS "film.film_id",
                film.title AS "film.title",
                film.rating AS "film.rating"
           FROM dvds.film
           WHERE film.rating = 'R'
-     ) AS films ON film_actor.film_id = films."film.film_id";
+     ) AS films ON (film_actor.film_id = films."film.film_id");
 `
 
 	rFilmsOnly := Film.SELECT(Film.FilmID, Film.Title, Film.Rating).
@@ -906,7 +906,7 @@ FROM dvds.customer
                SUM(payment.amount) AS "amount_sum"
           FROM dvds.payment
           GROUP BY payment.customer_id
-     ) AS customer_payment_sum ON customer.customer_id = customer_payment_sum."payment.customer_id"
+     ) AS customer_payment_sum ON (customer.customer_id = customer_payment_sum."payment.customer_id")
 ORDER BY customer_payment_sum.amount_sum ASC;
 `