diff --git a/sdk/cosmos/azure-spring-data-cosmos/src/main/java/com/azure/spring/data/cosmos/core/CosmosTemplate.java b/sdk/cosmos/azure-spring-data-cosmos/src/main/java/com/azure/spring/data/cosmos/core/CosmosTemplate.java
index 7b0043ca791b..c8ef03254879 100644
--- a/sdk/cosmos/azure-spring-data-cosmos/src/main/java/com/azure/spring/data/cosmos/core/CosmosTemplate.java
+++ b/sdk/cosmos/azure-spring-data-cosmos/src/main/java/com/azure/spring/data/cosmos/core/CosmosTemplate.java
@@ -36,6 +36,7 @@
 import org.springframework.context.ApplicationContextAware;
 import org.springframework.data.domain.Page;
 import org.springframework.data.domain.Pageable;
+import org.springframework.data.repository.query.parser.Part;
 import org.springframework.lang.NonNull;
 import org.springframework.util.Assert;
 import org.springframework.util.StringUtils;
@@ -462,7 +463,7 @@ public <T, ID> List<T> findByIds(Iterable<ID> ids, Class<T> domainType, String c
         Assert.hasText(containerName, "container should not be null, empty or only whitespaces");
 
         final DocumentQuery query = new DocumentQuery(Criteria.getInstance(CriteriaType.IN, "id",
-                Collections.singletonList(ids)));
+                Collections.singletonList(ids), Part.IgnoreCaseType.NEVER));
         return find(query, domainType, containerName);
     }
 
diff --git a/sdk/cosmos/azure-spring-data-cosmos/src/main/java/com/azure/spring/data/cosmos/core/generator/AbstractQueryGenerator.java b/sdk/cosmos/azure-spring-data-cosmos/src/main/java/com/azure/spring/data/cosmos/core/generator/AbstractQueryGenerator.java
index 680ec4045ac5..68719b5c3280 100644
--- a/sdk/cosmos/azure-spring-data-cosmos/src/main/java/com/azure/spring/data/cosmos/core/generator/AbstractQueryGenerator.java
+++ b/sdk/cosmos/azure-spring-data-cosmos/src/main/java/com/azure/spring/data/cosmos/core/generator/AbstractQueryGenerator.java
@@ -10,6 +10,7 @@
 import com.azure.spring.data.cosmos.exception.IllegalQueryException;
 import org.javatuples.Pair;
 import org.springframework.data.domain.Sort;
+import org.springframework.data.repository.query.parser.Part;
 import org.springframework.lang.NonNull;
 import org.springframework.util.Assert;
 import org.springframework.util.StringUtils;
@@ -53,13 +54,48 @@ private String generateBinaryQuery(@NonNull Criteria criteria, @NonNull List<Pai
         final String subject = criteria.getSubject();
         final Object subjectValue = toCosmosDbValue(criteria.getSubjectValues().get(0));
         final String parameter = generateQueryParameter(subject);
-
+        final Part.IgnoreCaseType ignoreCase = criteria.getIgnoreCase();
+        final String sqlKeyword = criteria.getType().getSqlKeyword();
         parameters.add(Pair.with(parameter, subjectValue));
 
         if (CriteriaType.isFunction(criteria.getType())) {
-            return String.format("%s(r.%s, @%s)", criteria.getType().getSqlKeyword(), subject, parameter);
+            return getFunctionCondition(ignoreCase, sqlKeyword, subject, parameter);
+        } else {
+            return getCondition(ignoreCase, sqlKeyword, subject, parameter);
+        }
+    }
+
+    /**
+     * Get condition string with function
+     * @param ignoreCase ignore case flag
+     * @param sqlKeyword sql key word, operation name
+     * @param subject sql column name
+     * @param parameter sql filter value
+     * @return condition string
+     */
+    private String getCondition(final Part.IgnoreCaseType ignoreCase, final String sqlKeyword,
+                                final String subject, final String parameter) {
+        if (Part.IgnoreCaseType.NEVER == ignoreCase) {
+            return String.format("r.%s %s @%s", subject, sqlKeyword, parameter);
+        } else {
+            return String.format("UPPER(r.%s) %s UPPER(@%s)", subject, sqlKeyword, parameter);
+        }
+    }
+
+    /**
+     * Get condition string without function
+     * @param ignoreCase ignore case flag
+     * @param sqlKeyword sql key word, operation name
+     * @param subject sql column name
+     * @param parameter sql filter value
+     * @return condition string
+     */
+    private String getFunctionCondition(final Part.IgnoreCaseType ignoreCase, final String sqlKeyword,
+                                        final String subject, final String parameter) {
+        if (Part.IgnoreCaseType.NEVER == ignoreCase) {
+            return String.format("%s(r.%s, @%s)", sqlKeyword, subject, parameter);
         } else {
-            return String.format("r.%s %s @%s", subject, criteria.getType().getSqlKeyword(), parameter);
+            return String.format("%s(UPPER(r.%s), UPPER(@%s))", sqlKeyword, subject, parameter);
         }
     }
 
diff --git a/sdk/cosmos/azure-spring-data-cosmos/src/main/java/com/azure/spring/data/cosmos/core/query/Criteria.java b/sdk/cosmos/azure-spring-data-cosmos/src/main/java/com/azure/spring/data/cosmos/core/query/Criteria.java
index 0028d67f5379..d95ad67a4130 100644
--- a/sdk/cosmos/azure-spring-data-cosmos/src/main/java/com/azure/spring/data/cosmos/core/query/Criteria.java
+++ b/sdk/cosmos/azure-spring-data-cosmos/src/main/java/com/azure/spring/data/cosmos/core/query/Criteria.java
@@ -2,6 +2,7 @@
 // Licensed under the MIT License.
 package com.azure.spring.data.cosmos.core.query;
 
+import org.springframework.data.repository.query.parser.Part;
 import org.springframework.lang.NonNull;
 
 import java.util.ArrayList;
@@ -16,6 +17,15 @@ public final class Criteria {
     private List<Object> subjectValues;
     private final CriteriaType type;
     private final List<Criteria> subCriteria;
+    private Part.IgnoreCaseType ignoreCase;
+
+    /**
+     * Ignore case flag
+     * @return ignore case flag
+     */
+    public Part.IgnoreCaseType getIgnoreCase() {
+        return ignoreCase;
+    }
 
     /**
      * To get subject
@@ -55,18 +65,20 @@ private Criteria(CriteriaType type) {
     }
 
     /**
-     * To get a criteria instance with subject
+     * To get a criteria instance with subject and ignore case
      * @param type CriteriaType
      * @param subject subject
      * @param values subject value
+     * @param ignoreCase ignore case flag
      * @return Criteria instance
      */
-    public static Criteria getInstance(CriteriaType type, @NonNull String subject, @NonNull List<Object> values) {
+    public static Criteria getInstance(CriteriaType type, @NonNull String subject,
+                                       @NonNull List<Object> values, @NonNull Part.IgnoreCaseType ignoreCase) {
         final Criteria criteria = new Criteria(type);
 
         criteria.subject = subject;
         criteria.subjectValues = values;
-
+        criteria.ignoreCase = ignoreCase;
         return criteria;
     }
 
diff --git a/sdk/cosmos/azure-spring-data-cosmos/src/main/java/com/azure/spring/data/cosmos/repository/query/CosmosQueryCreator.java b/sdk/cosmos/azure-spring-data-cosmos/src/main/java/com/azure/spring/data/cosmos/repository/query/CosmosQueryCreator.java
index ceafd6096c32..20c20a092323 100644
--- a/sdk/cosmos/azure-spring-data-cosmos/src/main/java/com/azure/spring/data/cosmos/repository/query/CosmosQueryCreator.java
+++ b/sdk/cosmos/azure-spring-data-cosmos/src/main/java/com/azure/spring/data/cosmos/repository/query/CosmosQueryCreator.java
@@ -74,7 +74,7 @@ protected Criteria create(Part part, Iterator<Object> parameters) {
             values.add(parameters.next());
         }
 
-        return Criteria.getInstance(CriteriaType.toCriteriaType(type), subject, values);
+        return Criteria.getInstance(CriteriaType.toCriteriaType(type), subject, values, part.shouldIgnoreCase());
     }
 
     @Override
diff --git a/sdk/cosmos/azure-spring-data-cosmos/src/main/java/com/azure/spring/data/cosmos/repository/query/ReactiveCosmosQueryCreator.java b/sdk/cosmos/azure-spring-data-cosmos/src/main/java/com/azure/spring/data/cosmos/repository/query/ReactiveCosmosQueryCreator.java
index 300651feefff..1ef6c82bd2df 100644
--- a/sdk/cosmos/azure-spring-data-cosmos/src/main/java/com/azure/spring/data/cosmos/repository/query/ReactiveCosmosQueryCreator.java
+++ b/sdk/cosmos/azure-spring-data-cosmos/src/main/java/com/azure/spring/data/cosmos/repository/query/ReactiveCosmosQueryCreator.java
@@ -72,7 +72,7 @@ protected Criteria create(Part part, Iterator<Object> parameters) {
             values.add(parameters.next());
         }
 
-        return Criteria.getInstance(CriteriaType.toCriteriaType(type), subject, values);
+        return Criteria.getInstance(CriteriaType.toCriteriaType(type), subject, values, part.shouldIgnoreCase());
     }
 
     @Override
diff --git a/sdk/cosmos/azure-spring-data-cosmos/src/test/java/com/azure/spring/data/cosmos/core/CosmosTemplateIT.java b/sdk/cosmos/azure-spring-data-cosmos/src/test/java/com/azure/spring/data/cosmos/core/CosmosTemplateIT.java
index c445b25be9ce..090902aca03a 100644
--- a/sdk/cosmos/azure-spring-data-cosmos/src/test/java/com/azure/spring/data/cosmos/core/CosmosTemplateIT.java
+++ b/sdk/cosmos/azure-spring-data-cosmos/src/test/java/com/azure/spring/data/cosmos/core/CosmosTemplateIT.java
@@ -31,6 +31,7 @@
 import org.springframework.data.domain.Page;
 import org.springframework.data.domain.PageRequest;
 import org.springframework.data.domain.Sort;
+import org.springframework.data.repository.query.parser.Part;
 import org.springframework.test.context.ContextConfiguration;
 import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
 
@@ -287,12 +288,20 @@ public void testCountByQuery() {
         assertThat(responseDiagnosticsTestUtils.getCosmosResponseStatistics()).isNull();
 
         final Criteria criteria = Criteria.getInstance(CriteriaType.IS_EQUAL, "firstName",
-                Collections.singletonList(TEST_PERSON_2.getFirstName()));
+                Collections.singletonList(TEST_PERSON_2.getFirstName()), Part.IgnoreCaseType.NEVER);
         final DocumentQuery query = new DocumentQuery(criteria);
 
         final long count = cosmosTemplate.count(query, Person.class, containerName);
         assertThat(count).isEqualTo(1);
 
+        // add ignoreCase testing
+        final Criteria criteriaIgnoreCase = Criteria.getInstance(CriteriaType.IS_EQUAL, "firstName",
+            Collections.singletonList(TEST_PERSON_2.getFirstName().toUpperCase()), Part.IgnoreCaseType.ALWAYS);
+        final DocumentQuery queryIgnoreCase = new DocumentQuery(criteriaIgnoreCase);
+
+        final long countIgnoreCase = cosmosTemplate.count(queryIgnoreCase, Person.class, containerName);
+        assertThat(countIgnoreCase).isEqualTo(1);
+
         assertThat(responseDiagnosticsTestUtils.getFeedResponseDiagnostics()).isNotNull();
         assertThat(responseDiagnosticsTestUtils.getCosmosResponseStatistics()).isNotNull();
         assertThat(responseDiagnosticsTestUtils.getCosmosResponseStatistics().getRequestCharge()).isGreaterThan(0);
@@ -339,7 +348,7 @@ public void testPaginationQuery() {
         assertThat(responseDiagnosticsTestUtils.getCosmosResponseStatistics()).isNull();
 
         final Criteria criteria = Criteria.getInstance(CriteriaType.IS_EQUAL, "firstName",
-                Collections.singletonList(FIRST_NAME));
+                Collections.singletonList(FIRST_NAME), Part.IgnoreCaseType.NEVER);
         final PageRequest pageRequest = new CosmosPageRequest(0, PAGE_SIZE_2, null);
         final DocumentQuery query = new DocumentQuery(criteria).with(pageRequest);
 
@@ -347,6 +356,15 @@ public void testPaginationQuery() {
         assertThat(page.getContent().size()).isEqualTo(1);
         PageTestUtils.validateLastPage(page, page.getContent().size());
 
+        // add ignore case testing
+        final Criteria criteriaIgnoreCase = Criteria.getInstance(CriteriaType.IS_EQUAL, "firstName",
+            Collections.singletonList(FIRST_NAME.toUpperCase()), Part.IgnoreCaseType.ALWAYS);
+        final DocumentQuery queryIgnoreCase = new DocumentQuery(criteriaIgnoreCase).with(pageRequest);
+
+        final Page<Person> pageIgnoreCase = cosmosTemplate.paginationQuery(queryIgnoreCase, Person.class, containerName);
+        assertThat(pageIgnoreCase.getContent().size()).isEqualTo(1);
+        PageTestUtils.validateLastPage(pageIgnoreCase, pageIgnoreCase.getContent().size());
+
         assertThat(responseDiagnosticsTestUtils.getCosmosResponseDiagnostics()).isNull();
         assertThat(responseDiagnosticsTestUtils.getFeedResponseDiagnostics()).isNotNull();
         assertThat(responseDiagnosticsTestUtils.getCosmosResponseStatistics()).isNotNull();
diff --git a/sdk/cosmos/azure-spring-data-cosmos/src/test/java/com/azure/spring/data/cosmos/core/CosmosTemplateIllegalTest.java b/sdk/cosmos/azure-spring-data-cosmos/src/test/java/com/azure/spring/data/cosmos/core/CosmosTemplateIllegalTest.java
index b569f8d21159..dd63b2e93040 100644
--- a/sdk/cosmos/azure-spring-data-cosmos/src/test/java/com/azure/spring/data/cosmos/core/CosmosTemplateIllegalTest.java
+++ b/sdk/cosmos/azure-spring-data-cosmos/src/test/java/com/azure/spring/data/cosmos/core/CosmosTemplateIllegalTest.java
@@ -14,6 +14,7 @@
 import org.mockito.Answers;
 import org.mockito.Mock;
 import org.mockito.junit.MockitoJUnitRunner;
+import org.springframework.data.repository.query.parser.Part;
 import org.springframework.util.Assert;
 
 import java.lang.reflect.InvocationTargetException;
@@ -42,8 +43,10 @@ public void setUp() {
 
     @Test
     public void deleteIllegalShouldFail() throws NoSuchMethodException {
-        final Method method = dbTemplateClass.getMethod("delete", DocumentQuery.class, Class.class, String.class);
-        final Criteria criteria = Criteria.getInstance(CriteriaType.IS_EQUAL, "faker", Arrays.asList("faker-value"));
+        final Method method = dbTemplateClass.getMethod("delete",
+            DocumentQuery.class, Class.class, String.class);
+        final Criteria criteria = Criteria.getInstance(CriteriaType.IS_EQUAL,
+            "faker", Arrays.asList("faker-value"), Part.IgnoreCaseType.NEVER);
         final DocumentQuery query = new DocumentQuery(criteria);
 
         checkIllegalArgument(method, null, Person.class, DUMMY_COLL);
diff --git a/sdk/cosmos/azure-spring-data-cosmos/src/test/java/com/azure/spring/data/cosmos/core/CosmosTemplatePartitionIT.java b/sdk/cosmos/azure-spring-data-cosmos/src/test/java/com/azure/spring/data/cosmos/core/CosmosTemplatePartitionIT.java
index b72787b917ca..adce25d05db4 100644
--- a/sdk/cosmos/azure-spring-data-cosmos/src/test/java/com/azure/spring/data/cosmos/core/CosmosTemplatePartitionIT.java
+++ b/sdk/cosmos/azure-spring-data-cosmos/src/test/java/com/azure/spring/data/cosmos/core/CosmosTemplatePartitionIT.java
@@ -27,6 +27,7 @@
 import org.springframework.data.annotation.Persistent;
 import org.springframework.data.domain.Page;
 import org.springframework.data.domain.PageRequest;
+import org.springframework.data.repository.query.parser.Part;
 import org.springframework.test.context.ContextConfiguration;
 import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
 
@@ -91,7 +92,8 @@ public static void afterClassCleanup() {
 
     @Test
     public void testFindWithPartition() {
-        Criteria criteria = Criteria.getInstance(CriteriaType.IS_EQUAL, PROPERTY_LAST_NAME, Arrays.asList(LAST_NAME));
+        Criteria criteria = Criteria.getInstance(CriteriaType.IS_EQUAL, PROPERTY_LAST_NAME,
+            Arrays.asList(LAST_NAME), Part.IgnoreCaseType.NEVER);
         DocumentQuery query = new DocumentQuery(criteria);
         List<PartitionPerson> result = cosmosTemplate.find(query, PartitionPerson.class,
                 PartitionPerson.class.getSimpleName());
@@ -99,9 +101,23 @@ public void testFindWithPartition() {
         assertThat(result.size()).isEqualTo(1);
         assertEquals(TEST_PERSON, result.get(0));
 
-        criteria = Criteria.getInstance(CriteriaType.IS_EQUAL, PROPERTY_ID, Arrays.asList(ID_1));
+        criteria = Criteria.getInstance(CriteriaType.IS_EQUAL, PROPERTY_ID,
+            Arrays.asList(ID_1), Part.IgnoreCaseType.NEVER);
         query = new DocumentQuery(criteria);
-        result = cosmosTemplate.find(query, PartitionPerson.class, PartitionPerson.class.getSimpleName());
+        result = cosmosTemplate.find(query, PartitionPerson.class,
+            PartitionPerson.class.getSimpleName());
+
+        assertThat(result.size()).isEqualTo(1);
+        assertEquals(TEST_PERSON, result.get(0));
+    }
+
+    @Test
+    public void testFindIgnoreCaseWithPartition() {
+        Criteria criteria = Criteria.getInstance(CriteriaType.IS_EQUAL, PROPERTY_LAST_NAME,
+            Arrays.asList(LAST_NAME.toUpperCase()), Part.IgnoreCaseType.ALWAYS);
+        DocumentQuery query = new DocumentQuery(criteria);
+        List<PartitionPerson> result = cosmosTemplate.find(query, PartitionPerson.class,
+            PartitionPerson.class.getSimpleName());
 
         assertThat(result.size()).isEqualTo(1);
         assertEquals(TEST_PERSON, result.get(0));
@@ -119,7 +135,8 @@ public void testFindByIdWithPartition() {
 
     @Test
     public void testFindByNonExistIdWithPartition() {
-        final Criteria criteria = Criteria.getInstance(CriteriaType.IS_EQUAL, PROPERTY_ID, Arrays.asList(NOT_EXIST_ID));
+        final Criteria criteria = Criteria.getInstance(CriteriaType.IS_EQUAL, PROPERTY_ID,
+            Arrays.asList(NOT_EXIST_ID), Part.IgnoreCaseType.NEVER);
         final DocumentQuery query = new DocumentQuery(criteria);
 
         final List<PartitionPerson> result = cosmosTemplate.find(query, PartitionPerson.class,
@@ -191,17 +208,29 @@ public void testCountForPartitionedCollectionByQuery() {
         cosmosTemplate.insert(TEST_PERSON_2, new PartitionKey(TEST_PERSON_2.getLastName()));
 
         final Criteria criteria = Criteria.getInstance(CriteriaType.IS_EQUAL, "firstName",
-                Arrays.asList(TEST_PERSON_2.getFirstName()));
+                Arrays.asList(TEST_PERSON_2.getFirstName()), Part.IgnoreCaseType.NEVER);
         final DocumentQuery query = new DocumentQuery(criteria);
 
         final long count = cosmosTemplate.count(query, PartitionPerson.class, containerName);
         assertThat(count).isEqualTo(1);
     }
 
+    @Test
+    public void testCountIgnoreCaseForPartitionedCollectionByQuery() {
+        cosmosTemplate.insert(TEST_PERSON_2, new PartitionKey(TEST_PERSON_2.getLastName()));
+        final Criteria criteriaIgnoreCase = Criteria.getInstance(CriteriaType.IS_EQUAL, "firstName",
+            Arrays.asList(TEST_PERSON_2.getFirstName().toUpperCase()), Part.IgnoreCaseType.ALWAYS);
+        final DocumentQuery queryIgnoreCase = new DocumentQuery(criteriaIgnoreCase);
+
+        final long countIgnoreCase = cosmosTemplate.count(queryIgnoreCase,
+            PartitionPerson.class, containerName);
+        assertThat(countIgnoreCase).isEqualTo(1);
+    }
+
     @Test
     public void testNonExistFieldValue() {
         final Criteria criteria = Criteria.getInstance(CriteriaType.IS_EQUAL, "firstName",
-                Arrays.asList("non-exist-first-name"));
+                Arrays.asList("non-exist-first-name"), Part.IgnoreCaseType.NEVER);
         final DocumentQuery query = new DocumentQuery(criteria);
 
         final long count = cosmosTemplate.count(query, PartitionPerson.class, containerName);
@@ -229,7 +258,7 @@ public void testPartitionedPaginationQuery() {
         cosmosTemplate.insert(TEST_PERSON_2, new PartitionKey(TEST_PERSON_2.getLastName()));
 
         final Criteria criteria = Criteria.getInstance(CriteriaType.IS_EQUAL, "firstName",
-                Arrays.asList(FIRST_NAME));
+                Arrays.asList(FIRST_NAME), Part.IgnoreCaseType.NEVER);
         final PageRequest pageRequest = new CosmosPageRequest(0, PAGE_SIZE_2, null);
         final DocumentQuery query = new DocumentQuery(criteria).with(pageRequest);
 
@@ -237,4 +266,18 @@ public void testPartitionedPaginationQuery() {
         assertThat(page.getContent().size()).isEqualTo(1);
         PageTestUtils.validateLastPage(page, page.getContent().size());
     }
+
+    @Test
+    public void testPartitionedPaginationQueryIgnoreCase() {
+        cosmosTemplate.insert(TEST_PERSON_2, new PartitionKey(TEST_PERSON_2.getLastName()));
+        final Criteria criteriaIgnoreCase = Criteria.getInstance(CriteriaType.IS_EQUAL, "firstName",
+            Arrays.asList(FIRST_NAME.toUpperCase()), Part.IgnoreCaseType.ALWAYS);
+        final PageRequest pageRequest = new CosmosPageRequest(0, PAGE_SIZE_2, null);
+        final DocumentQuery queryIgnoreCase = new DocumentQuery(criteriaIgnoreCase).with(pageRequest);
+
+        final Page<PartitionPerson> pageIgnoreCase = cosmosTemplate
+            .paginationQuery(queryIgnoreCase, PartitionPerson.class, containerName);
+        assertThat(pageIgnoreCase.getContent().size()).isEqualTo(1);
+        PageTestUtils.validateLastPage(pageIgnoreCase, pageIgnoreCase.getContent().size());
+    }
 }
diff --git a/sdk/cosmos/azure-spring-data-cosmos/src/test/java/com/azure/spring/data/cosmos/core/ReactiveCosmosTemplateIT.java b/sdk/cosmos/azure-spring-data-cosmos/src/test/java/com/azure/spring/data/cosmos/core/ReactiveCosmosTemplateIT.java
index 46c056d6ac94..9971897c3afa 100644
--- a/sdk/cosmos/azure-spring-data-cosmos/src/test/java/com/azure/spring/data/cosmos/core/ReactiveCosmosTemplateIT.java
+++ b/sdk/cosmos/azure-spring-data-cosmos/src/test/java/com/azure/spring/data/cosmos/core/ReactiveCosmosTemplateIT.java
@@ -27,6 +27,7 @@
 import org.springframework.boot.autoconfigure.domain.EntityScanner;
 import org.springframework.context.ApplicationContext;
 import org.springframework.data.annotation.Persistent;
+import org.springframework.data.repository.query.parser.Part;
 import org.springframework.test.context.ContextConfiguration;
 import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
 import reactor.core.publisher.Flux;
@@ -343,12 +344,20 @@ public void testDeleteByIdBySecondaryKey() {
     @Test
     public void testFind() {
         final Criteria criteria = Criteria.getInstance(CriteriaType.IS_EQUAL, "firstName",
-            Arrays.asList(TEST_PERSON.getFirstName()));
+            Arrays.asList(TEST_PERSON.getFirstName()), Part.IgnoreCaseType.NEVER);
         final DocumentQuery query = new DocumentQuery(criteria);
         final Flux<Person> personFlux = cosmosTemplate.find(query, Person.class,
             Person.class.getSimpleName());
         StepVerifier.create(personFlux).expectNextCount(1).verifyComplete();
 
+        // add ignore testing
+        final Criteria criteriaIgnoreCase = Criteria.getInstance(CriteriaType.IS_EQUAL, "firstName",
+            Arrays.asList(TEST_PERSON.getFirstName().toUpperCase()), Part.IgnoreCaseType.ALWAYS);
+        final DocumentQuery queryIgnoreCase = new DocumentQuery(criteriaIgnoreCase);
+        final Flux<Person> personFluxIgnoreCase = cosmosTemplate.find(queryIgnoreCase, Person.class,
+            Person.class.getSimpleName());
+        StepVerifier.create(personFluxIgnoreCase).expectNextCount(1).verifyComplete();
+
         assertThat(responseDiagnosticsTestUtils.getFeedResponseDiagnostics()).isNotNull();
         Assertions.assertThat(responseDiagnosticsTestUtils.getCosmosResponseStatistics()).isNotNull();
         Assertions.assertThat(responseDiagnosticsTestUtils.getCosmosResponseStatistics().getRequestCharge()).isGreaterThan(0);
@@ -358,11 +367,18 @@ public void testFind() {
     @Test
     public void testExists() {
         final Criteria criteria = Criteria.getInstance(CriteriaType.IS_EQUAL, "firstName",
-            Arrays.asList(TEST_PERSON.getFirstName()));
+            Arrays.asList(TEST_PERSON.getFirstName()), Part.IgnoreCaseType.NEVER);
         final DocumentQuery query = new DocumentQuery(criteria);
         final Mono<Boolean> exists = cosmosTemplate.exists(query, Person.class, containerName);
         StepVerifier.create(exists).expectNext(true).verifyComplete();
 
+        // add ignore testing
+        final Criteria criteriaIgnoreCase = Criteria.getInstance(CriteriaType.IS_EQUAL, "firstName",
+            Arrays.asList(TEST_PERSON.getFirstName().toUpperCase()), Part.IgnoreCaseType.ALWAYS);
+        final DocumentQuery queryIgnoreCase = new DocumentQuery(criteriaIgnoreCase);
+        final Mono<Boolean> existsIgnoreCase = cosmosTemplate.exists(queryIgnoreCase, Person.class, containerName);
+        StepVerifier.create(existsIgnoreCase).expectNext(true).verifyComplete();
+
         assertThat(responseDiagnosticsTestUtils.getFeedResponseDiagnostics()).isNotNull();
         Assertions.assertThat(responseDiagnosticsTestUtils.getCosmosResponseStatistics()).isNotNull();
         Assertions.assertThat(responseDiagnosticsTestUtils.getCosmosResponseStatistics().getRequestCharge()).isGreaterThan(0);
diff --git a/sdk/cosmos/azure-spring-data-cosmos/src/test/java/com/azure/spring/data/cosmos/core/ReactiveCosmosTemplatePartitionIT.java b/sdk/cosmos/azure-spring-data-cosmos/src/test/java/com/azure/spring/data/cosmos/core/ReactiveCosmosTemplatePartitionIT.java
index 934b6bb546fd..2e75a27f2e05 100644
--- a/sdk/cosmos/azure-spring-data-cosmos/src/test/java/com/azure/spring/data/cosmos/core/ReactiveCosmosTemplatePartitionIT.java
+++ b/sdk/cosmos/azure-spring-data-cosmos/src/test/java/com/azure/spring/data/cosmos/core/ReactiveCosmosTemplatePartitionIT.java
@@ -20,6 +20,7 @@
 import org.springframework.boot.autoconfigure.domain.EntityScanner;
 import org.springframework.context.ApplicationContext;
 import org.springframework.data.annotation.Persistent;
+import org.springframework.data.repository.query.parser.Part;
 import org.springframework.test.context.ContextConfiguration;
 import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
 import reactor.core.publisher.Flux;
@@ -89,7 +90,21 @@ public static void afterClassCleanup() {
     @Test
     public void testFindWithPartition() {
         final Criteria criteria = Criteria.getInstance(CriteriaType.IS_EQUAL, TestConstants.PROPERTY_LAST_NAME,
-            Arrays.asList(TestConstants.LAST_NAME));
+            Arrays.asList(TestConstants.LAST_NAME), Part.IgnoreCaseType.NEVER);
+        final DocumentQuery query = new DocumentQuery(criteria);
+        final Flux<PartitionPerson> partitionPersonFlux = cosmosTemplate.find(query,
+            PartitionPerson.class,
+            PartitionPerson.class.getSimpleName());
+        StepVerifier.create(partitionPersonFlux).consumeNextWith(actual -> {
+            Assert.assertThat(actual.getFirstName(), is(equalTo(TEST_PERSON.getFirstName())));
+            Assert.assertThat(actual.getLastName(), is(equalTo(TEST_PERSON.getLastName())));
+        }).verifyComplete();
+    }
+
+    @Test
+    public void testFindIgnoreCaseWithPartition() {
+        final Criteria criteria = Criteria.getInstance(CriteriaType.IS_EQUAL, TestConstants.PROPERTY_LAST_NAME,
+            Arrays.asList(TestConstants.LAST_NAME.toUpperCase()), Part.IgnoreCaseType.ALWAYS);
         final DocumentQuery query = new DocumentQuery(criteria);
         final Flux<PartitionPerson> partitionPersonFlux = cosmosTemplate.find(query,
             PartitionPerson.class,
@@ -181,11 +196,20 @@ public void testCountForPartitionedCollection() {
     public void testCountForPartitionedCollectionByQuery() {
         cosmosTemplate.insert(TEST_PERSON_2, new PartitionKey(TEST_PERSON_2.getLastName())).block();
         final Criteria criteria = Criteria.getInstance(CriteriaType.IS_EQUAL, "firstName",
-            Arrays.asList(TEST_PERSON_2.getFirstName()));
+            Arrays.asList(TEST_PERSON_2.getFirstName()), Part.IgnoreCaseType.NEVER);
         final DocumentQuery query = new DocumentQuery(criteria);
         StepVerifier.create(cosmosTemplate.count(query, containerName))
                     .expectNext((long) 1).verifyComplete();
+    }
 
+    @Test
+    public void testCountIgnoreCaseForPartitionedCollectionByQuery() {
+        cosmosTemplate.insert(TEST_PERSON_2, new PartitionKey(TEST_PERSON_2.getLastName())).block();
+        final Criteria criteriaIgnoreCase = Criteria.getInstance(CriteriaType.IS_EQUAL, "firstName",
+            Arrays.asList(TEST_PERSON_2.getFirstName().toUpperCase()), Part.IgnoreCaseType.ALWAYS);
+        final DocumentQuery queryIgnoreCase = new DocumentQuery(criteriaIgnoreCase);
+        StepVerifier.create(cosmosTemplate.count(queryIgnoreCase, containerName))
+            .expectNext((long) 1).verifyComplete();
     }
 }
 
diff --git a/sdk/cosmos/azure-spring-data-cosmos/src/test/java/com/azure/spring/data/cosmos/core/query/CriteriaUnitTest.java b/sdk/cosmos/azure-spring-data-cosmos/src/test/java/com/azure/spring/data/cosmos/core/query/CriteriaUnitTest.java
index 1128cefbf5a5..5ff98407b2de 100644
--- a/sdk/cosmos/azure-spring-data-cosmos/src/test/java/com/azure/spring/data/cosmos/core/query/CriteriaUnitTest.java
+++ b/sdk/cosmos/azure-spring-data-cosmos/src/test/java/com/azure/spring/data/cosmos/core/query/CriteriaUnitTest.java
@@ -6,6 +6,7 @@
 import com.azure.spring.data.cosmos.exception.IllegalQueryException;
 import org.junit.Assert;
 import org.junit.Test;
+import org.springframework.data.repository.query.parser.Part;
 
 import java.util.Arrays;
 import java.util.Collections;
@@ -19,20 +20,24 @@ public class CriteriaUnitTest {
     @Test
     public void testUnaryCriteria() {
         final List<Object> values = Arrays.asList(CRITERIA_OBJECT);
-        final Criteria criteria = Criteria.getInstance(CriteriaType.IS_EQUAL, CRITERIA_KEY, values);
+        final Criteria criteria = Criteria.getInstance(CriteriaType.IS_EQUAL,
+            CRITERIA_KEY, values, Part.IgnoreCaseType.NEVER);
 
         Assert.assertTrue(criteria.getSubCriteria().isEmpty());
         Assert.assertEquals(values, criteria.getSubjectValues());
         Assert.assertEquals(CriteriaType.IS_EQUAL, criteria.getType());
         Assert.assertEquals(CRITERIA_KEY, criteria.getSubject());
         Assert.assertTrue(CriteriaType.isBinary(criteria.getType()));
+        Assert.assertEquals(Part.IgnoreCaseType.NEVER, criteria.getIgnoreCase());
     }
 
     @Test
     public void testBinaryCriteria() {
         final List<Object> values = Arrays.asList(CRITERIA_OBJECT);
-        final Criteria leftCriteria = Criteria.getInstance(CriteriaType.IS_EQUAL, CRITERIA_KEY, values);
-        final Criteria rightCriteria = Criteria.getInstance(CriteriaType.IS_EQUAL, CRITERIA_OBJECT, values);
+        final Criteria leftCriteria = Criteria.getInstance(CriteriaType.IS_EQUAL,
+            CRITERIA_KEY, values, Part.IgnoreCaseType.NEVER);
+        final Criteria rightCriteria = Criteria.getInstance(CriteriaType.IS_EQUAL,
+            CRITERIA_OBJECT, values, Part.IgnoreCaseType.NEVER);
         final Criteria criteria = Criteria.getInstance(CriteriaType.AND, leftCriteria, rightCriteria);
 
         Assert.assertNotNull(criteria.getSubCriteria());
@@ -44,12 +49,16 @@ public void testBinaryCriteria() {
         Assert.assertEquals(2, criteria.getSubCriteria().size());
         Assert.assertEquals(leftCriteria, criteria.getSubCriteria().get(0));
         Assert.assertEquals(rightCriteria, criteria.getSubCriteria().get(1));
+
+        Assert.assertEquals(Part.IgnoreCaseType.NEVER, criteria.getSubCriteria().get(0).getIgnoreCase());
+        Assert.assertEquals(Part.IgnoreCaseType.NEVER, criteria.getSubCriteria().get(1).getIgnoreCase());
     }
 
     @Test(expected = IllegalQueryException.class)
     public void testInvalidInKeywordParameter() {
         final List<Object> values = Collections.singletonList(CRITERIA_OBJECT);
-        final Criteria criteria = Criteria.getInstance(CriteriaType.IN, CRITERIA_KEY, values);
+        final Criteria criteria = Criteria.getInstance(CriteriaType.IN,
+            CRITERIA_KEY, values, Part.IgnoreCaseType.NEVER);
         final DocumentQuery query = new DocumentQuery(criteria);
 
         new FindQuerySpecGenerator().generateCosmos(query);
@@ -58,7 +67,8 @@ public void testInvalidInKeywordParameter() {
     @Test(expected = IllegalQueryException.class)
     public void testInvalidInKeywordType() {
         final List<Object> values = Collections.singletonList(new IllegalQueryException(""));
-        final Criteria criteria = Criteria.getInstance(CriteriaType.IN, CRITERIA_KEY, values);
+        final Criteria criteria = Criteria.getInstance(CriteriaType.IN,
+            CRITERIA_KEY, values, Part.IgnoreCaseType.NEVER);
         final DocumentQuery query = new DocumentQuery(criteria);
 
         new FindQuerySpecGenerator().generateCosmos(query);
diff --git a/sdk/cosmos/azure-spring-data-cosmos/src/test/java/com/azure/spring/data/cosmos/core/query/DocumentQueryUnitTest.java b/sdk/cosmos/azure-spring-data-cosmos/src/test/java/com/azure/spring/data/cosmos/core/query/DocumentQueryUnitTest.java
index 06cdf4370ac6..553e4e9acf75 100644
--- a/sdk/cosmos/azure-spring-data-cosmos/src/test/java/com/azure/spring/data/cosmos/core/query/DocumentQueryUnitTest.java
+++ b/sdk/cosmos/azure-spring-data-cosmos/src/test/java/com/azure/spring/data/cosmos/core/query/DocumentQueryUnitTest.java
@@ -6,6 +6,7 @@
 import org.junit.Test;
 import org.springframework.data.domain.Pageable;
 import org.springframework.data.domain.Sort;
+import org.springframework.data.repository.query.parser.Part;
 
 import java.util.Arrays;
 
@@ -17,12 +18,13 @@ public class DocumentQueryUnitTest {
     @Test
     public void testDocumentQueryCreate() {
         final Criteria criteria = Criteria.getInstance(CriteriaType.IS_EQUAL, CRITERIA_KEY,
-                Arrays.asList(CRITERIA_OBJECT));
+                Arrays.asList(CRITERIA_OBJECT), Part.IgnoreCaseType.NEVER);
 
         final DocumentQuery query = new DocumentQuery(criteria);
 
         Assert.assertEquals(criteria, query.getCriteria());
         Assert.assertEquals(Sort.unsorted(), query.getSort());
         Assert.assertEquals(Pageable.unpaged(), query.getPageable());
+        Assert.assertEquals(Part.IgnoreCaseType.NEVER, criteria.getIgnoreCase());
     }
 }
diff --git a/sdk/cosmos/azure-spring-data-cosmos/src/test/java/com/azure/spring/data/cosmos/repository/integration/ReactiveCourseRepositoryIT.java b/sdk/cosmos/azure-spring-data-cosmos/src/test/java/com/azure/spring/data/cosmos/repository/integration/ReactiveCourseRepositoryIT.java
index df2780cfc216..d23671b4aa31 100644
--- a/sdk/cosmos/azure-spring-data-cosmos/src/test/java/com/azure/spring/data/cosmos/repository/integration/ReactiveCourseRepositoryIT.java
+++ b/sdk/cosmos/azure-spring-data-cosmos/src/test/java/com/azure/spring/data/cosmos/repository/integration/ReactiveCourseRepositoryIT.java
@@ -257,4 +257,24 @@ public void testFindAllByPartitionKey() {
                     })
                     .verifyComplete();
     }
+
+    @Test
+    public void testFindByNameIgnoreCase() {
+        final Flux<Course> findResult = repository.findByNameIgnoreCase(COURSE_NAME_1.toLowerCase());
+        StepVerifier.create(findResult).expectNext(COURSE_1).verifyComplete();
+    }
+
+    @Test
+    public void testFindByNameAndDepartmentAllIgnoreCase() {
+        final Flux<Course> findResult = repository.findByNameAndDepartmentAllIgnoreCase(
+            COURSE_NAME_1.toLowerCase(), DEPARTMENT_NAME_3.toLowerCase());
+        StepVerifier.create(findResult).expectNext(COURSE_1).verifyComplete();
+    }
+
+    @Test
+    public void testFindByNameOrDepartmentAllIgnoreCase() {
+        final Flux<Course> findResult = repository.findByNameOrDepartmentAllIgnoreCase(
+            COURSE_NAME_3.toLowerCase(), DEPARTMENT_NAME_3.toLowerCase());
+        StepVerifier.create(findResult).expectNext(COURSE_1, COURSE_3).verifyComplete();
+    }
 }
diff --git a/sdk/cosmos/azure-spring-data-cosmos/src/test/java/com/azure/spring/data/cosmos/repository/integration/StudentRepositoryIT.java b/sdk/cosmos/azure-spring-data-cosmos/src/test/java/com/azure/spring/data/cosmos/repository/integration/StudentRepositoryIT.java
index 5da443d21f66..36948a82e287 100644
--- a/sdk/cosmos/azure-spring-data-cosmos/src/test/java/com/azure/spring/data/cosmos/repository/integration/StudentRepositoryIT.java
+++ b/sdk/cosmos/azure-spring-data-cosmos/src/test/java/com/azure/spring/data/cosmos/repository/integration/StudentRepositoryIT.java
@@ -165,4 +165,53 @@ public void testExists() {
         assertTrue(repository.existsByLastNameContaining("N"));
         assertFalse(repository.existsByLastNameContaining("X"));
     }
+
+    @Test
+    public void testFindByLastNameIgnoreCase() {
+        List<Student> people = repository.findByLastNameIgnoreCase(LAST_NAME_0.toLowerCase());
+        assertPeopleEquals(people, Arrays.asList(STUDENT_0));
+        assertTrue(people.get(0).getLastName().equals(LAST_NAME_0));
+    }
+
+    @Test
+    public void testFindByLastNameAndFirstNameAllIgnoreCase() {
+        List<Student> people = repository
+            .findByLastNameAndFirstNameAllIgnoreCase(LAST_NAME_0.toLowerCase(), FIRST_NAME_0.toLowerCase());
+        assertPeopleEquals(people, Arrays.asList(STUDENT_0));
+        assertTrue(people.get(0).getFirstName().equals(FIRST_NAME_0));
+        assertTrue(people.get(0).getLastName().equals(LAST_NAME_0));
+    }
+
+    @Test
+    public void testFindByLastNameOrFirstNameAllIgnoreCase() {
+        List<Student> people = repository
+            .findByLastNameOrFirstNameAllIgnoreCase(LAST_NAME_0.toLowerCase(), FIRST_NAME_1.toLowerCase());
+        assertPeopleEquals(people, Arrays.asList(STUDENT_0, STUDENT_1));
+    }
+
+    @Test
+    public void testFindByFirstNameEndsWithIgnoreCase() {
+        List<Student> people = repository
+            .findByFirstNameEndsWithIgnoreCase(FIRST_NAME_0.toLowerCase().substring(2));
+        assertPeopleEquals(people, Arrays.asList(STUDENT_0));
+        assertTrue(people.get(0).getFirstName().equals(FIRST_NAME_0));
+    }
+
+    @Test
+    public void testFindByLastNameStartsWithAndFirstNameStartsWithAllIgnoreCase() {
+        List<Student> people = repository
+            .findByLastNameStartsWithAndFirstNameStartsWithAllIgnoreCase(
+                LAST_NAME_0.toLowerCase().substring(0, 2), FIRST_NAME_0.toLowerCase().substring(0, 2));
+        assertPeopleEquals(people, Arrays.asList(STUDENT_0));
+        assertTrue(people.get(0).getLastName().equals(LAST_NAME_0));
+        assertTrue(people.get(0).getFirstName().equals(FIRST_NAME_0));
+    }
+
+    @Test
+    public void testFindByLastNameStartsWithOrFirstNameStartsWithAllIgnoreCase() {
+        List<Student> people = repository
+            .findByLastNameStartsWithOrFirstNameStartsWithAllIgnoreCase(
+                LAST_NAME_0.toLowerCase().substring(0, 2), FIRST_NAME_1.toLowerCase().substring(0, 3));
+        assertPeopleEquals(people, Arrays.asList(STUDENT_0, STUDENT_1));
+    }
 }
diff --git a/sdk/cosmos/azure-spring-data-cosmos/src/test/java/com/azure/spring/data/cosmos/repository/repository/ReactiveCourseRepository.java b/sdk/cosmos/azure-spring-data-cosmos/src/test/java/com/azure/spring/data/cosmos/repository/repository/ReactiveCourseRepository.java
index 50f589f4b31e..ceaa3e87b0e8 100644
--- a/sdk/cosmos/azure-spring-data-cosmos/src/test/java/com/azure/spring/data/cosmos/repository/repository/ReactiveCourseRepository.java
+++ b/sdk/cosmos/azure-spring-data-cosmos/src/test/java/com/azure/spring/data/cosmos/repository/repository/ReactiveCourseRepository.java
@@ -2,8 +2,8 @@
 // Licensed under the MIT License.
 package com.azure.spring.data.cosmos.repository.repository;
 
-import com.azure.spring.data.cosmos.repository.ReactiveCosmosRepository;
 import com.azure.spring.data.cosmos.domain.Course;
+import com.azure.spring.data.cosmos.repository.ReactiveCosmosRepository;
 import reactor.core.publisher.Flux;
 
 import java.util.Collection;
@@ -11,4 +11,27 @@
 public interface ReactiveCourseRepository extends ReactiveCosmosRepository<Course, String> {
 
     Flux<Course> findByDepartmentIn(Collection<String> departments);
+
+    /**
+     * Find Course list by name without case sensitive
+     * @param name name
+     * @return Course list
+     */
+    Flux<Course> findByNameIgnoreCase(String name);
+
+    /**
+     * Find Course list by name and department without case sensitive
+     * @param name name
+     * @param department department
+     * @return Course list
+     */
+    Flux<Course> findByNameAndDepartmentAllIgnoreCase(String name, String department);
+
+    /**
+     * Find Course list by name or department without case sensitive
+     * @param name name
+     * @param department department
+     * @return Course list
+     */
+    Flux<Course> findByNameOrDepartmentAllIgnoreCase(String name, String department);
 }
diff --git a/sdk/cosmos/azure-spring-data-cosmos/src/test/java/com/azure/spring/data/cosmos/repository/repository/StudentRepository.java b/sdk/cosmos/azure-spring-data-cosmos/src/test/java/com/azure/spring/data/cosmos/repository/repository/StudentRepository.java
index f8039bc21388..e543d74b07be 100644
--- a/sdk/cosmos/azure-spring-data-cosmos/src/test/java/com/azure/spring/data/cosmos/repository/repository/StudentRepository.java
+++ b/sdk/cosmos/azure-spring-data-cosmos/src/test/java/com/azure/spring/data/cosmos/repository/repository/StudentRepository.java
@@ -32,4 +32,51 @@ public interface StudentRepository extends CosmosRepository<Student, String> {
     Boolean existsByFirstName(String firstName);
 
     Boolean existsByLastNameContaining(String lastName);
+
+    /**
+     * Find student list by last name without case sensitive
+     * @param lastName last name
+     * @return student list
+     */
+    List<Student> findByLastNameIgnoreCase(String lastName);
+
+    /**
+     * Find student list by last name and first name without case sensitive
+     * @param lastName last name
+     * @param firstName first name
+     * @return student list
+     */
+    List<Student> findByLastNameAndFirstNameAllIgnoreCase(String lastName, String firstName);
+
+    /**
+     * Find student list by last name or first name without case sensitive
+     * @param lastName last name
+     * @param firstName first name
+     * @return Student list
+     */
+    List<Student> findByLastNameOrFirstNameAllIgnoreCase(String lastName, String firstName);
+
+    /**
+     * Find student list by first name matching end without case sensitive
+     * @param firstName
+     * @return
+     */
+    List<Student> findByFirstNameEndsWithIgnoreCase(String firstName);
+
+    /**
+     * Find student list by last name matching end and first name matching end without case sensitive
+     * @param lastName
+     * @param firstName
+     * @return
+     */
+    List<Student> findByLastNameStartsWithAndFirstNameStartsWithAllIgnoreCase(String lastName, String firstName);
+
+    /**
+     * Find student list by last name matching or and first name matching end without case sensitive
+     * @param lastName
+     * @param firstName
+     * @return
+     */
+    List<Student> findByLastNameStartsWithOrFirstNameStartsWithAllIgnoreCase(String lastName, String firstName);
+
 }