home *** CD-ROM | disk | FTP | other *** search
/ Complete Linux / Complete Linux.iso / docs / apps / database / postgres / postgre4.z / postgre4 / src / planner / util / ordering.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-08-27  |  2.5 KB  |  91 lines
  1.  
  2. /*     
  3.  *      FILE
  4.  *         ordering
  5.  *     
  6.  *      DESCRIPTION
  7.  *         Routines to manipulate and compare merge and path orderings
  8.  *     
  9.  *      EXPORTS
  10.  *             equal-path-path-ordering
  11.  *             equal-path-merge-ordering
  12.  *             equal-merge-merge-ordering
  13.  *
  14.  *    $Header: /private/postgres/src/planner/util/RCS/ordering.c,v 1.10 1992/03/31 23:14:58 mer Exp $
  15.  */
  16.  
  17. #include "planner/internal.h"
  18.  
  19. /*    
  20.  *        equal-path-path-ordering
  21.  *    
  22.  *        Returns t iff two path orderings are equal.
  23.  *    
  24.  */
  25.  
  26. /*  .. find-index-paths, in-line-lambda%598037446, in-line-lambda%598037501
  27.  *  .. sort-relation-paths
  28.  */
  29. bool
  30. equal_path_path_ordering (path_ordering1,path_ordering2)
  31.      LispValue path_ordering1,path_ordering2 ;
  32. {
  33.     if (path_ordering1 == path_ordering2)
  34.     return true;
  35.     if (!path_ordering1 || !path_ordering2)
  36.     return false;
  37.     if ((IsA(path_ordering1,MergeOrder) && IsA(path_ordering2,MergeOrder)) ||
  38.     (!IsA(path_ordering1,MergeOrder) && !IsA(path_ordering2,MergeOrder)))
  39.     return equal((Node)path_ordering1, (Node)path_ordering2);
  40.     if (IsA(path_ordering1,MergeOrder) && !IsA(path_ordering2,MergeOrder))
  41.     return path_ordering2 && get_left_operator((MergeOrder)path_ordering1) == 
  42.                  CInteger(CAR(path_ordering2));
  43.     return path_ordering1 && CInteger(CAR(path_ordering1)) ==
  44.                  get_left_operator((MergeOrder)path_ordering2);
  45. }
  46.  
  47. /*    
  48.  *        equal-path-merge-ordering
  49.  *    
  50.  *        Returns t iff a path ordering is usable for ordering a merge join.
  51.  *     XXX    Presently, this means that the first sortop of the path matches
  52.  *        either of the merge sortops.  Is there a "right" and "wrong"
  53.  *        sortop to match?
  54.  *    
  55.  */
  56.  
  57. /*  .. in-line-lambda%598037346, in-line-lambda%598037477
  58.  */
  59. bool
  60. equal_path_merge_ordering (path_ordering,merge_ordering)
  61.      LispValue path_ordering,merge_ordering ;
  62. {
  63.     /* XXX - let form, maybe incorrect */
  64.     LispValue path_sortop = CAR (path_ordering);
  65.     if (merge_ordering == LispNil) return(false);
  66.     if ((CInteger(path_sortop) == get_left_operator((MergeOrder)merge_ordering)) ||
  67.         (CInteger(path_sortop) == get_right_operator((MergeOrder)merge_ordering)))
  68.       return(true);
  69.     else
  70.       return(false);
  71. }
  72.  
  73. /*    
  74.  *        equal-merge-merge-ordering
  75.  *    
  76.  *        Returns t iff two merge orderings are equal.
  77.  *    
  78.  */
  79.  
  80. /*  .. in-line-lambda%598037477
  81.  */
  82. bool
  83. equal_merge_merge_ordering (merge_ordering1,merge_ordering2)
  84.      LispValue merge_ordering1,merge_ordering2 ;
  85. {
  86.     if (equal ((Node)merge_ordering1,(Node)merge_ordering2))
  87.       return(true);
  88.     else
  89.       return(false);
  90. }
  91.