type QueryCriteriaWithDateTimeType struct { 	CreatedDate time.Time `soql:"equalsOperator,fieldName=CreatedDate"` } +type QueryCriteriaWithPtrDateTimeType struct {+	CreatedDate *time.Time `soql:"equalsOperator,fieldName=CreatedDate"`

 var _ = Describe("Marshaller", func() { 			}) 		}) +		Context("when all clauses are pointers to date time data types", func() {

 func marshalWhereClause(v interface{}, tableName string) (string, error) { // This will print whereClause as: // (Host_Name__c LIKE '%-db%' OR Host_Name__c LIKE '%-dbmgmt%') AND Role__r.Name IN ('db','dbmgmt') AND ((NOT Host_Name__c LIKE '%-core%') AND (NOT Host_Name__c LIKE '%-drp%')) AND Tech_Asset__r.Asset_Type_Asset_Type__c = 'SERVER' AND Last_Discovered_Date__c != null AND Num_of_CPU_Cores__c > 16 func MarshalWhereClause(v interface{}) (string, error) {-	return marshalWhereClause(v, "")+	return marshalWhereClause(v, "", andCondition) }  func getClauseKey(clauseTag string) string { 	tagItems := strings.Split(clauseTag, ",") 	return tagItems[0] } +func getJoiner(clauseTag string) (string, error) {+	tag := getTagValue(clauseTag, Joiner, "")+	switch strings.ToLower(tag) {+	case "or":+		return orCondition, nil+	case "and", "":+		return andCondition, nil+	default:

 type NonNestedStruct struct {  1. `selectClause`: This tag is used on the struct which should be considered for generating part of SOQL query that contains columns/fields that should be selected. It should be used only on `struct` type. If used on types other than `struct` then `ErrInvalidTag` error will be returned. This tag is associated with `tableName` parameter. It specifies the name of the table (Salesforce object) from which the columns should be selected. If not specified name of the field is used as table name (Salesforce object). In the snippet above `SelectClause` member of `TestSoqlStruct` is tagged with `selectClause` to indicate that members in `NonNestedStruct` should be considered as fields to be selected from Salesforce object `SM_SomeObject__c`. -1. `whereClause`: This tag is used on the struct which encapsulates the query criteria for SOQL query. There are no parameters for this tag. In the snippet above `WhereClause` member of `TestSoqlStruct` is tagged with `whereClause` to indicate that members in `TestQueryCriteria` should be considered for generating `WHERE` clause in SOQL query. If there are more than one field in `TestQueryCriteria` struct then they will be combined using `AND` logical operator.+1. `whereClause`: This tag is used on the struct which encapsulates the query criteria for SOQL query. There is an optional parameter `joiner` for this tag. In the snippet above `WhereClause` member of `TestSoqlStruct` is tagged with `whereClause` to indicate that members in `TestQueryCriteria` should be considered for generating `WHERE` clause in SOQL query. If there are more than one field in `TestQueryCriteria` struct then they will be combined using `AND` logical operator. If the `joiner` parameter is set to `or`, then the fields will be combined using `OR` logical operator.  Any other value including no value will use the `AND` logical operator. The `joiner` parameter is only supported when using `Marshal`; when calling `MarshalWhereClause`, the fields will always be combined with the `AND` logical operator.

 var _ = Describe("Marshaller", func() { 				Expect(actualQuery).To(Equal(expectedQuery)) 			}) 		})++		Context("when a struct with where clause with joiner=OR passed", func() {+			BeforeEach(func() {+				soqlStruct = orSOQLQuery{+					WhereClause: positionOrDeptCriteria{+						Title:      "Purchasing Manager",+						Department: "Accounting",+					},+				}+				expectedQuery = "SELECT Name,Email,Phone FROM Contact WHERE Title = 'Purchasing Manager' OR Department = 'Accounting'"+			})++			It("returns properly constructed soql query", func() {+				Expect(err).ToNot(HaveOccurred())+				Expect(actualQuery).To(Equal(expectedQuery))+			})+		})++		Context("when a struct with where clause with joiner=or passed", func() {+			BeforeEach(func() {+				soqlStruct = orLowerSOQLQuery{+					WhereClause: positionOrDeptCriteria{+						Title:      "Purchasing Manager",+						Department: "Accounting",+					},+				}+				expectedQuery = "SELECT Name,Email,Phone FROM Contact WHERE Title = 'Purchasing Manager' OR Department = 'Accounting'"+			})++			It("returns properly constructed soql query", func() {+				Expect(err).ToNot(HaveOccurred())+				Expect(actualQuery).To(Equal(expectedQuery))+			})+		})++		Context("when a struct with where clause with joiner=AND passed", func() {+			BeforeEach(func() {+				soqlStruct = andSOQLQuery{+					WhereClause: positionOrDeptCriteria{+						Title:      "Purchasing Manager",+						Department: "Accounting",+					},+				}+				expectedQuery = "SELECT Name,Email,Phone FROM Contact WHERE Title = 'Purchasing Manager' AND Department = 'Accounting'"+			})++			It("returns properly constructed soql query", func() {+				Expect(err).ToNot(HaveOccurred())+				Expect(actualQuery).To(Equal(expectedQuery))+			})+		})++		Context("when a struct with where clause with joiner=ELSE (an invalid value) passed", func() {+			BeforeEach(func() {+				soqlStruct = invalidJoinerSOQLQuery{+					WhereClause: positionOrDeptCriteria{+						Title:      "Purchasing Manager",+						Department: "Accounting",+					},+				}+				expectedQuery = "SELECT Name,Email,Phone FROM Contact WHERE Title = 'Purchasing Manager' AND Department = 'Accounting'"+			})++			It("returns properly constructed soql query", func() {+				Expect(err).ToNot(HaveOccurred())

 func marshalWhereClause(v interface{}, tableName string) (string, error) { 		fieldType := reflectedType.Field(i) 		clauseTag := fieldType.Tag.Get(SoqlTag) 		clauseKey := getClauseKey(clauseTag)-		fieldName := getFieldName(clauseTag, fieldType.Name)-		if fieldName == "" {-			return "", ErrInvalidTag-		}-		fn, ok := clauseBuilderMap[clauseKey]-		if !ok {-			return "", ErrInvalidTag-		}-		columnName := fieldName-		if tableName != "" {-			columnName = tableName + period + fieldName-		}-		partialClause, err := fn(field.Interface(), columnName)-		if err != nil {-			return "", err+		var partialClause string+		if clauseKey == Subquery {+			if field.Kind() != reflect.Struct {+				return "", ErrInvalidTag+			}+			partialClause, err = marshalWhereClause(field.Interface(), tableName, getJoiner(clauseTag))+			if err != nil {+				return "", err+			}++			partialClause = "(" + partialClause + ")"

 func marshalOrderByClause(v interface{}, tableName string, s interface{}) (strin  } +// v is the limit value provided+func marshalLimitClause(v interface{}) (string, error) {+	s, err := marshalIntValue(v)+	if err != nil {+		return "", ErrInvalidLimitClause+	}+	return s, nil+}++// v is the offset value provided+func marshalOffsetClause(v interface{}) (string, error) {+	s, err := marshalIntValue(v)+	if err != nil {+		return "", ErrInvalidOffsetClause+	}+	return s, nil+}++func marshalIntValue(v interface{}) (string, error) {+	limit, ok := v.(int)+	if !ok {+		return "", errors.New("invalid type")+	}+	if limit < 0 {+		return "", errors.New("invalid value")+	}++	var vString string+	if limit > 0 {

 func marshalOrderByClause(v interface{}, tableName string, s interface{}) (strin  } +// v is the limit value provided+func marshalLimitClause(v interface{}) (string, error) {+	s, err := marshalIntValue(v)+	if err != nil {+		return "", ErrInvalidLimitClause+	}+	return s, nil+}++// v is the offset value provided+func marshalOffsetClause(v interface{}) (string, error) {+	s, err := marshalIntValue(v)+	if err != nil {+		return "", ErrInvalidOffsetClause+	}+	return s, nil+}++func marshalIntValue(v interface{}) (string, error) {+	limit, ok := v.(int)+	if !ok {+		return "", errors.New("invalid type")+	}+	if limit < 0 {+		return "", errors.New("invalid value")+	}++	var vString string+	if limit > 0 {

 const ( 	WhereClause = "whereClause" 	// OrderByClause is the tag to be used when marking the string slice to be considered for order by clause 	OrderByClause = "orderByClause"+	// LimitClause is the tag to be used when marking the string slice to be considered for limit clause

 const ( 	WhereClause = "whereClause" 	// OrderByClause is the tag to be used when marking the string slice to be considered for order by clause 	OrderByClause = "orderByClause"+	// LimitClause is the tag to be used when marking the string slice to be considered for limit clause+	LimitClause = "limitClause"+	// OffsetClause is the tag to be used when marking the string slice to be considered for offset clause

 var _ = Describe("Marshaller", func() { 				Expect(actualQuery).To(Equal(expectedQuery)) 			}) 		})++		Context("when a struct with limit value is passed", func() {+			BeforeEach(func() {+				soqlStruct = TestSoqlLimitStruct{+					SelectClause: NestedStruct{},+					WhereClause: TestQueryCriteria{+						IncludeNamePattern: []string{"-db", "-dbmgmt"},+						Roles:              []string{"db", "dbmgmt"},+					},+					Limit: 5,+				}+				expectedQuery = "SELECT Id,Name__c,NonNestedStruct__r.Name,NonNestedStruct__r.SomeValue__c FROM SM_Logical_Host__c WHERE (Host_Name__c LIKE '%-db%' OR Host_Name__c LIKE '%-dbmgmt%') AND Role__r.Name IN ('db','dbmgmt') LIMIT 5"+			})++			It("returns properly constructed soql query", func() {+				Expect(err).ToNot(HaveOccurred())+				Expect(actualQuery).To(Equal(expectedQuery))+			})+		})++		Context("when a struct without limit value is passed", func() {+			BeforeEach(func() {+				soqlStruct = TestSoqlLimitStruct{+					SelectClause: NestedStruct{},+					WhereClause: TestQueryCriteria{+						IncludeNamePattern: []string{"-db", "-dbmgmt"},+						Roles:              []string{"db", "dbmgmt"},+					},+				}+				expectedQuery = "SELECT Id,Name__c,NonNestedStruct__r.Name,NonNestedStruct__r.SomeValue__c FROM SM_Logical_Host__c WHERE (Host_Name__c LIKE '%-db%' OR Host_Name__c LIKE '%-dbmgmt%') AND Role__r.Name IN ('db','dbmgmt')"+			})++			It("returns properly constructed soql query", func() {+				Expect(err).ToNot(HaveOccurred())+				Expect(actualQuery).To(Equal(expectedQuery))+			})+		})++		Context("when a struct with invalid limit type is passed", func() {+			BeforeEach(func() {+				soqlStruct = TestSoqlInvalidLimitStruct{+					SelectClause: NestedStruct{},+					WhereClause: TestQueryCriteria{+						IncludeNamePattern: []string{"-db", "-dbmgmt"},+						Roles:              []string{"db", "dbmgmt"},+					},+					Limit: "5",+				}+			})++			It("returns error", func() {+				Expect(err).To(Equal(ErrInvalidLimitClause))+			})+		})++		Context("when a struct with invalid limit value is passed", func() {+			BeforeEach(func() {+				soqlStruct = TestSoqlLimitStruct{+					SelectClause: NestedStruct{},+					WhereClause: TestQueryCriteria{+						IncludeNamePattern: []string{"-db", "-dbmgmt"},+						Roles:              []string{"db", "dbmgmt"},+					},+					Limit: -5,+				}+			})++			It("returns error", func() {+				Expect(err).To(Equal(ErrInvalidLimitClause))+			})+		})++		Context("when a struct with multiple limit values is passed", func() {+			BeforeEach(func() {+				soqlStruct = TestSoqlMultipleLimitStruct{+					SelectClause: NestedStruct{},+					WhereClause: TestQueryCriteria{+						IncludeNamePattern: []string{"-db", "-dbmgmt"},+						Roles:              []string{"db", "dbmgmt"},+					},+					Limit:     5,+					AlsoLimit: 15,+				}+			})++			It("returns error", func() {+				Expect(err).To(Equal(ErrMultipleLimitClause))+			})+		})++		Context("when a struct with limit inside a child relation is passed", func() {+			BeforeEach(func() {+				soqlStruct = TestSoqlChildRelationLimitStruct{+					SelectClause: ParentLimitStruct{+						ChildStruct: ChildLimitStruct{+							Limit: 1,+						},+					},+				}+				expectedQuery = "SELECT Id,Name__c,(SELECT Application_Versions__c.Id,Application_Versions__c.Version__c FROM Application_Versions__r LIMIT 1) FROM SM_Logical_Host__c"+			})++			It("returns properly constructed soql query", func() {+				Expect(err).ToNot(HaveOccurred())+				Expect(actualQuery).To(Equal(expectedQuery))+			})+		})++		Context("when a struct with limit inside a child relation is passed", func() {+			BeforeEach(func() {+				soqlStruct = TestSoqlChildRelationLimitStruct{+					SelectClause: ParentLimitStruct{+						ChildStruct: ChildLimitStruct{+							Limit: 10,+						},+					},+					Limit: 25,+				}+				expectedQuery = "SELECT Id,Name__c,(SELECT Application_Versions__c.Id,Application_Versions__c.Version__c FROM Application_Versions__r LIMIT 10) FROM SM_Logical_Host__c LIMIT 25"+			})++			It("returns properly constructed soql query", func() {+				Expect(err).ToNot(HaveOccurred())+				Expect(actualQuery).To(Equal(expectedQuery))+			})+		})++		Context("when a struct with offset value is passed", func() {+			BeforeEach(func() {+				soqlStruct = TestSoqlOffsetStruct{+					SelectClause: NestedStruct{},+					WhereClause: TestQueryCriteria{+						IncludeNamePattern: []string{"-db", "-dbmgmt"},+						Roles:              []string{"db", "dbmgmt"},+					},+					Offset: 5,+				}+				expectedQuery = "SELECT Id,Name__c,NonNestedStruct__r.Name,NonNestedStruct__r.SomeValue__c FROM SM_Logical_Host__c WHERE (Host_Name__c LIKE '%-db%' OR Host_Name__c LIKE '%-dbmgmt%') AND Role__r.Name IN ('db','dbmgmt') OFFSET 5"+			})++			It("returns properly constructed soql query", func() {+				Expect(err).ToNot(HaveOccurred())+				Expect(actualQuery).To(Equal(expectedQuery))+			})+		})++		Context("when a struct without offset value is passed", func() {+			BeforeEach(func() {+				soqlStruct = TestSoqlOffsetStruct{+					SelectClause: NestedStruct{},+					WhereClause: TestQueryCriteria{+						IncludeNamePattern: []string{"-db", "-dbmgmt"},+						Roles:              []string{"db", "dbmgmt"},+					},+				}+				expectedQuery = "SELECT Id,Name__c,NonNestedStruct__r.Name,NonNestedStruct__r.SomeValue__c FROM SM_Logical_Host__c WHERE (Host_Name__c LIKE '%-db%' OR Host_Name__c LIKE '%-dbmgmt%') AND Role__r.Name IN ('db','dbmgmt')"+			})++			It("returns properly constructed soql query", func() {+				Expect(err).ToNot(HaveOccurred())+				Expect(actualQuery).To(Equal(expectedQuery))+			})+		})++		Context("when a struct with invalid offset type is passed", func() {+			BeforeEach(func() {+				soqlStruct = TestSoqlInvalidOffsetStruct{+					SelectClause: NestedStruct{},+					WhereClause: TestQueryCriteria{+						IncludeNamePattern: []string{"-db", "-dbmgmt"},+						Roles:              []string{"db", "dbmgmt"},+					},+					Offset: "5",+				}+			})++			It("returns error", func() {+				Expect(err).To(Equal(ErrInvalidOffsetClause))+			})+		})++		Context("when a struct with invalid offset value is passed", func() {+			BeforeEach(func() {+				soqlStruct = TestSoqlOffsetStruct{+					SelectClause: NestedStruct{},+					WhereClause: TestQueryCriteria{+						IncludeNamePattern: []string{"-db", "-dbmgmt"},+						Roles:              []string{"db", "dbmgmt"},+					},+					Offset: -5,+				}+			})++			It("returns error", func() {+				Expect(err).To(Equal(ErrInvalidOffsetClause))+			})+		})++		Context("when a struct with multiple offset values is passed", func() {+			BeforeEach(func() {+				soqlStruct = TestSoqlMultipleOffsetStruct{+					SelectClause: NestedStruct{},+					WhereClause: TestQueryCriteria{+						IncludeNamePattern: []string{"-db", "-dbmgmt"},+						Roles:              []string{"db", "dbmgmt"},+					},+					Offset:     5,+					AlsoOffset: 15,+				}+			})++			It("returns error", func() {+				Expect(err).To(Equal(ErrMultipleOffsetClause))+			})+		})

 func marshalOrderByClause(v interface{}, tableName string, s interface{}) (strin  } +// v is the limit value provided+func marshalLimitClause(v interface{}) (string, error) {+	s, err := marshalIntValue(v)+	if err != nil {+		return "", ErrInvalidLimitClause+	}+	return s, nil+}++// v is the offset value provided+func marshalOffsetClause(v interface{}) (string, error) {+	s, err := marshalIntValue(v)+	if err != nil {+		return "", ErrInvalidOffsetClause+	}+	return s, nil+}++func marshalIntValue(v interface{}) (string, error) {+	limit, ok := v.(int)+	if !ok {+		return "", errors.New("invalid type")+	}+	if limit < 0 {+		return "", errors.New("invalid value")+	}++	var vString string+	if limit > 0 {