(file) Return to WQLSelectStatement.h CVS log (file) (dir) Up to [Pegasus] / pegasus / src / Pegasus / WQL

Diff for /pegasus/src/Pegasus/WQL/WQLSelectStatement.h between version 1.1.2.5 and 1.14.8.1

version 1.1.2.5, 2001/12/12 17:45:53 version 1.14.8.1, 2006/02/10 16:14:27
Line 1 
Line 1 
 //%/////////////////////////////////////////////////////////////////////////////  //%2006////////////////////////////////////////////////////////////////////////
 // //
 // Copyright (c) 2000, 2001 BMC Software, Hewlett-Packard Company, IBM,  // Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development
 // The Open Group, Tivoli Systems  // Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems.
   // Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L.P.;
   // IBM Corp.; EMC Corporation, The Open Group.
   // Copyright (c) 2004 BMC Software; Hewlett-Packard Development Company, L.P.;
   // IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.
   // Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.;
   // EMC Corporation; VERITAS Software Corporation; The Open Group.
   // Copyright (c) 2006 Hewlett-Packard Development Company, L.P.; IBM Corp.;
   // EMC Corporation; Symantec Corporation; The Open Group.
 // //
 // Permission is hereby granted, free of charge, to any person obtaining a copy // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to // of this software and associated documentation files (the "Software"), to
Line 23 
Line 31 
 // //
 // Author: Mike Brasher (mbrasher@bmc.com) // Author: Mike Brasher (mbrasher@bmc.com)
 // //
 // Modified By:  // Modified By: Carol Ann Krug Graves, Hewlett-Packard Company
   //                  (carolann_graves@hp.com)
   //              David Dillard, VERITAS Software Corp.
   //                  (david.dillard@veritas.com)
 // //
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
  
Line 31 
Line 42 
 #define Pegasus_WQLSelectStatement_h #define Pegasus_WQLSelectStatement_h
  
 #include <Pegasus/Common/Config.h> #include <Pegasus/Common/Config.h>
 #include <Pegasus/Common/Array.h>  #include <Pegasus/WQL/Linkage.h>
 #include <Pegasus/Common/String.h>  #include <Pegasus/Common/ArrayInternal.h>
   #include <Pegasus/Common/CIMName.h>
   #include <Pegasus/Common/CIMPropertyList.h>
   #include <Pegasus/Common/CIMInstance.h>
   #include <Pegasus/Common/CIMObject.h>
 #include <Pegasus/WQL/WQLOperation.h> #include <Pegasus/WQL/WQLOperation.h>
 #include <Pegasus/WQL/WQLOperand.h> #include <Pegasus/WQL/WQLOperand.h>
 #include <Pegasus/WQL/WQLPropertySource.h> #include <Pegasus/WQL/WQLPropertySource.h>
   #include <Pegasus/Query/QueryCommon/SelectStatement.h>
   #include <Pegasus/Query/QueryCommon/QueryContext.h>
  
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
  
   
   class PEGASUS_WQL_LINKAGE WQLSelectStatementRep;
   
 /** This class represents a compiled WQL1 select statement. /** This class represents a compiled WQL1 select statement.
  
     An instance of WQLSelectStatement is passed to WQLParser::parse() which     An instance of WQLSelectStatement is passed to WQLParser::parse() which
Line 59 
Line 79 
     YACC parser). Evaluation is performed using a Boolean stack. See the     YACC parser). Evaluation is performed using a Boolean stack. See the
     implementation of evaluateWhereClause() for details.     implementation of evaluateWhereClause() for details.
 */ */
 class PEGASUS_WQL_LINKAGE WQLSelectStatement  class PEGASUS_WQL_LINKAGE WQLSelectStatement: public SelectStatement
 { {
 public: public:
  
   
       WQLSelectStatement(String& queryLang, String& query);
   
       WQLSelectStatement(String& queryLang, String& query, QueryContext& inCtx);
   
     /** Default constructor.     /** Default constructor.
     */     */
     WQLSelectStatement();     WQLSelectStatement();
  
       WQLSelectStatement(const WQLSelectStatement& statement);
   
     /** Destructor.     /** Destructor.
     */     */
     ~WQLSelectStatement();     ~WQLSelectStatement();
  
       WQLSelectStatement& operator=(const WQLSelectStatement& rhs);
   
     /** Clears all data members of this object.     /** Clears all data members of this object.
     */     */
     void clear();     void clear();
  
     /** Accessor.     /** Accessor.
     */     */
     const String& getClassName() const      const CIMName& getClassName() const;
     {  
         return _className;  
     }  
  
     /** Modifier. This method should not be called by the user (only by the     /** Modifier. This method should not be called by the user (only by the
         parser).         parser).
     */     */
     void setClassName(const String& className)      void setClassName(const CIMName& className);
     {  
         _className = className;      /**
     }          Returns true if the query selects all properties ("*")
       */
       Boolean getAllProperties() const;
   
       /**
           Used by the parser to indicate the query selects all properties ("*")
           This method should not be called by the user (only by the parser).
       */
       void setAllProperties(const Boolean allProperties);
  
     /** Returns the number of property names which were indicated in the     /** Returns the number of property names which were indicated in the
         selection list.         selection list.
           This function should only be used if getAllProperties() returns false.
     */     */
     Uint32 getSelectPropertyNameCount() const      Uint32 getSelectPropertyNameCount() const;
     {  
         return _selectPropertyNames.size();  
     }  
  
     /** Gets the i-th selected property name in the list.     /** Gets the i-th selected property name in the list.
           This function should only be used if getAllProperties() returns false.
     */     */
     const String& getSelectPropertyName(Uint32 i)      const CIMName& getSelectPropertyName(Uint32 i) const;
     {  
         return _selectPropertyNames[i];      /**
     }          Returns the required properties from the SELECT clause for the specified
           class.
   
           @param  inClassName  name of the class; must be one of the classes from
                                the FROM clause
  
     /** Appends a property name to the property name list. This user should          @return  CIMPropertyList containing the required properties from the
                    SELECT clause for the specified class;
                    or a null CIMPropertyList if all properties of the specified
                    class are required
       */
       CIMPropertyList getSelectPropertyList
           (const CIMObjectPath& inClassName = CIMObjectPath ());
   
       /** Appends a property name to the property name list. The user should
         not call this method; it should only be called by the parser.         not call this method; it should only be called by the parser.
     */     */
     void appendSelectPropertyName(const String& x)      void appendSelectPropertyName(const CIMName& x);
     {  
         _selectPropertyNames.append(x);  
     }  
  
     /** Returns the number of unique property names from the where clause.     /** Returns the number of unique property names from the where clause.
     */     */
     Uint32 getWherePropertyNameCount() const      Uint32 getWherePropertyNameCount() const;
     {  
         return _wherePropertyNames.size();  
     }  
  
     /** Gets the i-th unique property appearing in the where clause.     /** Gets the i-th unique property appearing in the where clause.
     */     */
     const String& getWherePropertyName(Uint32 i)      const CIMName& getWherePropertyName(Uint32 i) const;
     {  
         return _wherePropertyNames[i];      /**
     }          Returns the required properties from the WHERE clause for the specified
           class.
   
           @param  inClassName  name of the class; must be one of the classes from
                                the FROM clause
   
           @return  CIMPropertyList containing the required properties from the
                    WHERE clause for the specified class;
                    or a null CIMPropertyList if all properties of the specified
                    class are required
       */
       CIMPropertyList getWherePropertyList
           (const CIMObjectPath& inClassName = CIMObjectPath ());
  
     /** Appends a property name to the where property name list. This user      /** Appends a property name to the where property name list. The user
         should not call this method; it should only be called by the parser.         should not call this method; it should only be called by the parser.
  
         @param x name of the property.         @param x name of the property.
         @return false if a property with that name already exists.         @return false if a property with that name already exists.
     */     */
     Boolean appendWherePropertyName(const String& x);      Boolean appendWherePropertyName(const CIMName& x);
  
     /** Appends an operation to the operation array. This method should only     /** Appends an operation to the operation array. This method should only
         be called by the parser itself.         be called by the parser itself.
     */     */
     void appendOperation(WQLOperation x)      void appendOperation(WQLOperation x);
     {  
         _operations.append(x);  
     }  
  
     /** Appends an operand to the operation array. This method should only     /** Appends an operand to the operation array. This method should only
         be called by the parser itself.         be called by the parser itself.
     */     */
     void appendOperand(const WQLOperand& x)      void appendOperand(const WQLOperand& x);
     {  
         _operands.append(x);  
     }  
  
     /** Returns true if this class has a where clause.     /** Returns true if this class has a where clause.
     */     */
     Boolean hasWhereClause() const      Boolean hasWhereClause() const;
     {  
         return _operations.size() != 0;  
     }  
  
     /** Evalautes the where clause using the symbol table to resolve symbols.     /** Evalautes the where clause using the symbol table to resolve symbols.
     */     */
     Boolean evaluateWhereClause(const WQLPropertySource* source) const;     Boolean evaluateWhereClause(const WQLPropertySource* source) const;
  
       /** Inspect an instance and remove properties not listed in Select projection.
   
           @param  allowMissing  Boolean specifying whether missing project
                                 properties are allowed
           @exception Exception
       */
       void applyProjection(CIMInstance& inst,
           Boolean allowMissing);
       void applyProjection(CIMObject& inst,
           Boolean allowMissing);
   
     /** Prints out the members of this class.     /** Prints out the members of this class.
     */     */
     void print() const;     void print() const;
  
 private:      static const WQLSelectStatement EMPTY;
   
     //  
     // The name of the target class. For example:  
     //  
     //     SELECT *  
     //     FROM TargetClass  
     //     WHERE ...  
     //  
   
     String _className;  
   
     //  
     // The list of property names being selected. For example, see "firstName",  
     // and "lastName" below.  
     //  
     //     SELECT firstName, lastName  
     //     FROM TargetClass  
     //     WHERE ...  
     //  
  
     Array<String> _selectPropertyNames;      Boolean evaluate(const CIMInstance& inCI);
  
     //      void validate();
     // The unique list of property names appearing in the WHERE clause.  
     // Although a property may occur many times in the WHERE clause, it will  
     // only appear once in this list.  
     //  
  
     Array<String> _wherePropertyNames;      CIMPropertyList getPropertyList(const CIMObjectPath& inClassName = CIMObjectPath());
  
     //      Array<CIMObjectPath> getClassPathList();
     // The list of operations encountered while parsing the WHERE clause.  
     // Consider this query:  
     //  
     //     SELECT *  
     //     FROM TargetClass  
     //     WHERE count > 10 OR peak < 20 AND state = "OKAY"  
     //  
     // This would generate the following stream of WQLOperations:  
     //  
     //     WQL_GT  
     //     WQL_LT  
     //     WQL_EQ  
     //     WQL_AND  
     //     WQL_OR  
     //  
  
     Array<WQLOperation> _operations;  private:
  
     //      WQLSelectStatementRep* _rep;
     // The list of operands encountered while parsing the WHERE clause. They  
     // query just above would generate the following stream of operands:  
     //  
     //     count, 10, peak, 20, state, "OKAY"  
     //  
  
     Array<WQLOperand> _operands;      //void f() const { }
  
     void f() const { }      friend class CMPI_Wql2Dnf;
 }; };
  
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END

Legend:
Removed from v.1.1.2.5  
changed lines
  Added in v.1.14.8.1
No CVS admin address has been configured
 Powered by
ViewCVS 0.9.2