diff --git a/api/src/main/java/jakarta/data/metamodel/Attribute.java b/api/src/main/java/jakarta/data/metamodel/Attribute.java
index 220c501a0..c5963091a 100644
--- a/api/src/main/java/jakarta/data/metamodel/Attribute.java
+++ b/api/src/main/java/jakarta/data/metamodel/Attribute.java
@@ -22,6 +22,7 @@
 import java.util.Set;
 
 import jakarta.data.Sort;
+import jakarta.data.metamodel.Restrict.BasicRestriction;
 import jakarta.data.metamodel.Restriction.Operator;
 
 /**
@@ -31,16 +32,16 @@
  */
 public interface Attribute<T> {
 
-    default <V> Restriction.Single<T, V> equal(V value) {
-        return new Restriction.Single<>(name(), Operator.EQUAL, value);
+    default <V> BasicRestriction<T, V> equal(V value) {
+        return new BasicRestriction<>(name(), Operator.EQUAL, value);
     }
 
-    default <V> Restriction.Single<T, Set<V>> in(@SuppressWarnings("unchecked") V... values) {
-        return new Restriction.Single<>(name(), Operator.IN, Set.of(values));
+    default <V> BasicRestriction<T, Set<V>> in(@SuppressWarnings("unchecked") V... values) {
+        return new BasicRestriction<>(name(), Operator.IN, Set.of(values));
     }
 
-    default Restriction.Single<T, Object> isNull() {
-        return new Restriction.Single<>(name(), Operator.EQUAL, null);
+    default BasicRestriction<T, Object> isNull() {
+        return new BasicRestriction<>(name(), Operator.EQUAL, null);
     }
 
     /**
@@ -51,15 +52,15 @@ default Restriction.Single<T, Object> isNull() {
      */
     String name();
 
-    default <V> Restriction.Single<T, V> not(V value) {
-        return new Restriction.Single<>(name(), NOT, Operator.EQUAL, value);
+    default <V> BasicRestriction<T, V> not(V value) {
+        return new BasicRestriction<>(name(), NOT, Operator.EQUAL, value);
     }
 
-    default <V> Restriction.Single<T, Set<V>> notIn(@SuppressWarnings("unchecked") V... values) {
-        return new Restriction.Single<>(name(), NOT, Operator.IN, Set.of(values));
+    default <V> BasicRestriction<T, Set<V>> notIn(@SuppressWarnings("unchecked") V... values) {
+        return new BasicRestriction<>(name(), NOT, Operator.IN, Set.of(values));
     }
 
-    default Restriction.Single<T, Object> notNull() {
-        return new Restriction.Single<>(name(), NOT, Operator.EQUAL, null);
+    default BasicRestriction<T, Object> notNull() {
+        return new BasicRestriction<>(name(), NOT, Operator.EQUAL, null);
     }
 }
diff --git a/api/src/main/java/jakarta/data/metamodel/Restrict.java b/api/src/main/java/jakarta/data/metamodel/Restrict.java
index d77d6c940..0ef5d8ebc 100644
--- a/api/src/main/java/jakarta/data/metamodel/Restrict.java
+++ b/api/src/main/java/jakarta/data/metamodel/Restrict.java
@@ -29,14 +29,49 @@ public enum Restrict {
 
     @SafeVarargs
     static <T> Restriction<T> all(Restriction<T>... restrictions) {
-        return new Restriction.Multiple<>(All, List.of(restrictions));
+        return new CompositeRestriction<>(All, List.of(restrictions));
     }
 
     @SafeVarargs
     static <T> Restriction<T> any(Restriction<T>... restrictions) {
-        return new Restriction.Multiple<>(Any, List.of(restrictions));
+        return new CompositeRestriction<>(Any, List.of(restrictions));
     }
 
     // TODO Need to think more about how to best cover negation of multiple
     // and then make negation of Single consistent with it
+
+    // The following are internal implementation classes.
+    // The proper way for users to obtain instances is via the static metamodel.
+
+    record BasicRestriction<T, V>(
+            String field,
+            boolean negated,
+            Operator comparison,
+            boolean ignoreCase,
+            V value) implements Restriction.Basic<T, V> {
+
+        BasicRestriction(String field, boolean negated, Operator comparison, V value) {
+            this(field, negated, comparison, false, value);
+        }
+
+        BasicRestriction(String field, Operator comparison, V value) {
+            this(field, false, comparison, false, value);
+        }
+
+        BasicRestriction(String field, Operator comparison, boolean ignoreCase, V value) {
+            this(field, false, comparison, ignoreCase, value);
+        }
+    }
+
+    record CompositeRestriction<T>(
+            Restrict type,
+            List<Restriction<T>> restrictions,
+            boolean negated) implements Restriction.Composite<T> {
+
+        CompositeRestriction(
+                Restrict type,
+                List<Restriction<T>> restrictions) {
+            this(type, restrictions, false);
+        }
+    }
 }
diff --git a/api/src/main/java/jakarta/data/metamodel/Restriction.java b/api/src/main/java/jakarta/data/metamodel/Restriction.java
index d0fb8ffa0..f58fbad98 100644
--- a/api/src/main/java/jakarta/data/metamodel/Restriction.java
+++ b/api/src/main/java/jakarta/data/metamodel/Restriction.java
@@ -20,40 +20,33 @@
 import java.util.List;
 
 public interface Restriction<T> {
-    record Multiple<T>(
-                    Restrict type,
-                    List<Restriction<T>> list) implements Restriction<T> {
+    interface Basic<T, V> extends Restriction<T> {
+        Operator comparison();
+
+        String field();
+
+        boolean ignoreCase();
+
+        boolean negated();
+
+        V value();
     }
 
-    record Single<T, V>(
-                    String name,
-                    boolean negated,
-                    Operator comparison,
-                    boolean ignoreCase,
-                    V value) implements Restriction<T> {
-        Single(String name, boolean negated, Operator comparison, V value) {
-            this(name, negated, comparison, false, value);
-        }
-
-        Single(String name, Operator comparison, V value) {
-            this(name, false, comparison, false, value);
-        }
-
-        Single(String name, Operator comparison, boolean ignoreCase, V value) {
-            this(name, false, comparison, ignoreCase, value);
-        }
+    interface Composite<T> extends Restriction<T> {
+        List<Restriction<T>> restrictions();
+
+        Restrict type();
+
+        boolean negated();
     }
 
     enum Operator {
-        CONTAINS,
-        ENDS_WITH,
         EQUAL,
         GREATER_THAN,
         GREATER_THAN_EQUAL,
         IN,
         LESS_THAN,
         LESS_THAN_EQUAL,
-        LIKE,
-        STARTS_WITH
+        LIKE
     }
 }
diff --git a/api/src/main/java/jakarta/data/metamodel/SortableAttribute.java b/api/src/main/java/jakarta/data/metamodel/SortableAttribute.java
index a57168bb5..bde4607ed 100644
--- a/api/src/main/java/jakarta/data/metamodel/SortableAttribute.java
+++ b/api/src/main/java/jakarta/data/metamodel/SortableAttribute.java
@@ -18,6 +18,7 @@
 package jakarta.data.metamodel;
 
 import jakarta.data.Sort;
+import jakarta.data.metamodel.Restrict.BasicRestriction;
 import jakarta.data.metamodel.Restriction.Operator;
 
 /**
@@ -50,19 +51,19 @@ public interface SortableAttribute<T> extends Attribute<T> {
      */
     Sort<T> desc();
 
-    default <V> Restriction.Single<T, V> greaterThan(V value) {
-        return new Restriction.Single<>(name(), Operator.GREATER_THAN, value);
+    default <V> BasicRestriction<T, V> greaterThan(V value) {
+        return new BasicRestriction<>(name(), Operator.GREATER_THAN, value);
     }
 
-    default <V> Restriction.Single<T, V> greaterThanEqual(V value) {
-        return new Restriction.Single<>(name(), Operator.GREATER_THAN_EQUAL, value);
+    default <V> BasicRestriction<T, V> greaterThanEqual(V value) {
+        return new BasicRestriction<>(name(), Operator.GREATER_THAN_EQUAL, value);
     }
 
-    default <V> Restriction.Single<T, V> lessThan(V value) {
-        return new Restriction.Single<>(name(), Operator.LESS_THAN, value);
+    default <V> BasicRestriction<T, V> lessThan(V value) {
+        return new BasicRestriction<>(name(), Operator.LESS_THAN, value);
     }
 
-    default <V> Restriction.Single<T, V> lessThanEqual(V value) {
-        return new Restriction.Single<>(name(), Operator.LESS_THAN_EQUAL, value);
+    default <V> BasicRestriction<T, V> lessThanEqual(V value) {
+        return new BasicRestriction<>(name(), Operator.LESS_THAN_EQUAL, value);
     }
 }
diff --git a/api/src/main/java/jakarta/data/metamodel/TextAttribute.java b/api/src/main/java/jakarta/data/metamodel/TextAttribute.java
index bc8119bc2..664df8706 100644
--- a/api/src/main/java/jakarta/data/metamodel/TextAttribute.java
+++ b/api/src/main/java/jakarta/data/metamodel/TextAttribute.java
@@ -21,6 +21,7 @@
 import static jakarta.data.metamodel.Restrict.NOT;
 
 import jakarta.data.Sort;
+import jakarta.data.metamodel.Restrict.BasicRestriction;
 import jakarta.data.metamodel.Restriction.Operator;
 
 /**
@@ -37,12 +38,12 @@ public interface TextAttribute<T> extends SortableAttribute<T> {
      */
     Sort<T> ascIgnoreCase();
 
-    default Restriction.Single<T, String> contains(String pattern) {
-        return new Restriction.Single<>(name(), Operator.CONTAINS, pattern);
+    default BasicRestriction<T, String> contains(String pattern) {
+        return new BasicRestriction<>(name(), Operator.LIKE, '%' + pattern + '%');
     }
 
-    default Restriction.Single<T, String> containsIgnoreCase(String pattern) {
-        return new Restriction.Single<>(name(), Operator.CONTAINS, IGNORE_CASE, pattern);
+    default BasicRestriction<T, String> containsIgnoreCase(String pattern) {
+        return new BasicRestriction<>(name(), Operator.LIKE, IGNORE_CASE, '%' + pattern + '%');
     }
 
     /**
@@ -52,68 +53,68 @@ default Restriction.Single<T, String> containsIgnoreCase(String pattern) {
      */
     Sort<T> descIgnoreCase();
 
-    default Restriction.Single<T, String> endsWith(String pattern) {
-        return new Restriction.Single<>(name(), Operator.ENDS_WITH, pattern);
+    default BasicRestriction<T, String> endsWith(String pattern) {
+        return new BasicRestriction<>(name(), Operator.LIKE, '%' + pattern);
     }
 
-    default Restriction.Single<T, String> endsWithIgnoreCase(String pattern) {
-        return new Restriction.Single<>(name(), Operator.ENDS_WITH, IGNORE_CASE, pattern);
+    default BasicRestriction<T, String> endsWithIgnoreCase(String pattern) {
+        return new BasicRestriction<>(name(), Operator.LIKE, IGNORE_CASE, '%' + pattern);
     }
 
-    default Restriction.Single<T, String> equalIgnoreCase(String value) {
-        return new Restriction.Single<>(name(), Operator.EQUAL, IGNORE_CASE, value);
+    default BasicRestriction<T, String> equalIgnoreCase(String value) {
+        return new BasicRestriction<>(name(), Operator.EQUAL, IGNORE_CASE, value);
     }
 
-    default Restriction.Single<T, String> like(String pattern) {
-        return new Restriction.Single<>(name(), Operator.LIKE, pattern);
+    default BasicRestriction<T, String> like(String pattern) {
+        return new BasicRestriction<>(name(), Operator.LIKE, pattern);
     }
 
-    default Restriction.Single<T, String> likeIgnoreCase(String pattern) {
-        return new Restriction.Single<>(name(), Operator.LIKE, IGNORE_CASE, pattern);
+    default BasicRestriction<T, String> likeIgnoreCase(String pattern) {
+        return new BasicRestriction<>(name(), Operator.LIKE, IGNORE_CASE, pattern);
     }
 
-    default Restriction.Single<T, String> notContains(String pattern) {
-        return new Restriction.Single<>(name(), NOT, Operator.CONTAINS, pattern);
+    default BasicRestriction<T, String> notContains(String pattern) {
+        return new BasicRestriction<>(name(), NOT, Operator.LIKE, '%' + pattern + '%');
     }
 
-    default Restriction.Single<T, String> notContainsIgnoreCase(String pattern) {
-        return new Restriction.Single<>(name(), NOT, Operator.CONTAINS, IGNORE_CASE, pattern);
+    default BasicRestriction<T, String> notContainsIgnoreCase(String pattern) {
+        return new BasicRestriction<>(name(), NOT, Operator.LIKE, IGNORE_CASE, '%' + pattern + '%');
     }
 
-    default Restriction.Single<T, String> notEndsWith(String pattern) {
-        return new Restriction.Single<>(name(), NOT, Operator.ENDS_WITH, pattern);
+    default BasicRestriction<T, String> notEndsWith(String pattern) {
+        return new BasicRestriction<>(name(), NOT, Operator.LIKE, '%' + pattern);
     }
 
-    default Restriction.Single<T, String> notEndsWithIgnoreCase(String pattern) {
-        return new Restriction.Single<>(name(), NOT, Operator.ENDS_WITH, IGNORE_CASE, pattern);
+    default BasicRestriction<T, String> notEndsWithIgnoreCase(String pattern) {
+        return new BasicRestriction<>(name(), NOT, Operator.LIKE, IGNORE_CASE, '%' + pattern);
     }
 
-    default Restriction.Single<T, String> notIgnoreCase(String value) {
-        return new Restriction.Single<>(name(), NOT, Operator.EQUAL, IGNORE_CASE, value);
+    default BasicRestriction<T, String> notIgnoreCase(String value) {
+        return new BasicRestriction<>(name(), NOT, Operator.EQUAL, IGNORE_CASE, value);
     }
 
-    default Restriction.Single<T, String> notLike(String pattern) {
-        return new Restriction.Single<>(name(), NOT, Operator.LIKE, pattern);
+    default BasicRestriction<T, String> notLike(String pattern) {
+        return new BasicRestriction<>(name(), NOT, Operator.LIKE, pattern);
     }
 
-    default Restriction.Single<T, String> notLikeIgnoreCase(String pattern) {
-        return new Restriction.Single<>(name(), NOT, Operator.LIKE, IGNORE_CASE, pattern);
+    default BasicRestriction<T, String> notLikeIgnoreCase(String pattern) {
+        return new BasicRestriction<>(name(), NOT, Operator.LIKE, IGNORE_CASE, pattern);
     }
 
-    default Restriction.Single<T, String> notStartsWith(String pattern) {
-        return new Restriction.Single<>(name(), NOT, Operator.STARTS_WITH, pattern);
+    default BasicRestriction<T, String> notStartsWith(String pattern) {
+        return new BasicRestriction<>(name(), NOT, Operator.LIKE, pattern + '%');
     }
 
-    default Restriction.Single<T, String> notStartsWithIgnoreCase(String pattern) {
-        return new Restriction.Single<>(name(), NOT, Operator.STARTS_WITH, IGNORE_CASE, pattern);
+    default BasicRestriction<T, String> notStartsWithIgnoreCase(String pattern) {
+        return new BasicRestriction<>(name(), NOT, Operator.LIKE, IGNORE_CASE, pattern + '%');
     }
 
-    default Restriction.Single<T, String> startsWith(String pattern) {
-        return new Restriction.Single<>(name(), Operator.STARTS_WITH, pattern);
+    default BasicRestriction<T, String> startsWith(String pattern) {
+        return new BasicRestriction<>(name(), Operator.LIKE, pattern + '%');
     }
 
-    default Restriction.Single<T, String> startsWithIgnoreCase(String pattern) {
-        return new Restriction.Single<>(name(), Operator.STARTS_WITH, IGNORE_CASE, pattern);
+    default BasicRestriction<T, String> startsWithIgnoreCase(String pattern) {
+        return new BasicRestriction<>(name(), Operator.LIKE, IGNORE_CASE, pattern + '%');
     }
 
 }