Add clone tests and adjust and/or logic

Author: AdrianCurtin

lib/parse/query.rb

@@ -2489,27 +2489,73 @@ def convert_dates_for_aggregation(obj)
       end
     end
 
-    # Combines multiple queries with OR logic
+    # Combines multiple queries with OR logic using full pipeline approach
+    # Each query's complete constraint set becomes one branch of the OR condition
     # @param queries [Array<Parse::Query>] the queries to combine with OR logic
     # @return [Parse::Query] a new query with OR constraints
+    # @raise [ArgumentError] if the queries don't all target the same Parse class
     def self.or(*queries)
       queries = queries.flatten.compact
+      return nil if queries.empty?
+      
+      # Get the table from the first query
       table = queries.first.table
+      
+      # Ensure all queries are for the same table
+      unless queries.all? { |q| q.table == table }
+        raise ArgumentError, "All queries passed to Parse::Query.or must be for the same Parse class."
+      end
+      
+      # Start with an empty query for this table
       result = self.new(table)
+      
+      # Filter to only queries that have constraints
       queries = queries.filter { |q| q.where.present? && !q.where.empty? }
-      queries.each { |query| result.or_where(query.where) }
+      
+      # Add each query's complete constraint set as an OR branch
+      queries.each do |query|
+        # Compile the where constraints to check if they result in empty conditions
+        compiled_where = Parse::Query.compile_where(query.where)
+        unless compiled_where.empty?
+          result.or_where(query.where)
+        end
+      end
+      
       result
     end
 
-    # Combines multiple queries with AND logic
+    # Combines multiple queries with AND logic using full pipeline approach
+    # Each query's complete constraint set is ANDed together
     # @param queries [Array<Parse::Query>] the queries to combine with AND logic
     # @return [Parse::Query] a new query with AND constraints
+    # @raise [ArgumentError] if the queries don't all target the same Parse class
     def self.and(*queries)
       queries = queries.flatten.compact
+      return nil if queries.empty?
+      
+      # Get the table from the first query
       table = queries.first.table
+      
+      # Ensure all queries are for the same table
+      unless queries.all? { |q| q.table == table }
+        raise ArgumentError, "All queries passed to Parse::Query.and must be for the same Parse class."
+      end
+      
+      # Start with an empty query for this table
       result = self.new(table)
+      
+      # Filter to only queries that have constraints
       queries = queries.filter { |q| q.where.present? && !q.where.empty? }
-      queries.each { |query| result.where(query.where) }
+      
+      # Add each query's complete constraint set with AND logic
+      queries.each do |query|
+        # Compile the where constraints to check if they result in empty conditions
+        compiled_where = Parse::Query.compile_where(query.where)
+        unless compiled_where.empty?
+          result.where(query.where)
+        end
+      end
+      
       result
     end
 
@@ -2523,7 +2569,14 @@ def clone
         if instance_variable_defined?(:"@#{param}")
           value = instance_variable_get(:"@#{param}")
           if value.is_a?(Array) || value.is_a?(Hash)
-            cloned_value = Marshal.load(Marshal.dump(value)) rescue value.dup
+            # Use Marshal for deep copy of complex constraint objects
+            begin
+              cloned_value = Marshal.load(Marshal.dump(value))
+            rescue => e
+              # Fallback to shallow copy if Marshal fails
+              puts "[Parse::Query.clone] Marshal failed for #{param}: #{e.message}, falling back to dup"
+              cloned_value = value.dup
+            end
           else
             cloned_value = value
           end