(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.2 and 1.12

version 1.1.2.2, 2001/12/03 00:58:05 version 1.12, 2005/02/05 23:00:52
Line 1 
Line 1 
 //%/////////////////////////////////////////////////////////////////////////////  //%2005////////////////////////////////////////////////////////////////////////
 // //
 // 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.
 // //
 // 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 29 
 // //
 // 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)
 // //
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
  
Line 31 
Line 38 
 #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
  
 /** This class represents a compiled WBEMSQl1 select statement.  
   class PEGASUS_WQL_LINKAGE WQLSelectStatementRep;
   
   /** 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
     parses and WBEMSQL1 SELECT statement and initializes the WQLSelectStatement      parses the WQL1 SELECT statement and initializes the WQLSelectStatement
     instance. The WBEMSWL1 SELECT statement has the following form:      instance. A WQL1 SELECT statement has the following form:
  
     <pre>     <pre>
         SELECT <property>...          SELECT &lt;property&gt;...
         FROM <class name>          FROM &lt;class name&gt;
         WHERE <where clause>          WHERE &lt;where clause&gt;
     </pre>     </pre>
  
     The properties may be obtained with the getProperties() method.      There are methods for obtaining the various elements of the select
     The class name may be obtained with getClassName(). The where clause      statement.
     may be evaluated by calling evaluateWhereClause() with the appropriate  
     arguments. If hasWhereClause() returns false, then there is no where  
     clause.  
  
     The components of the where clause are stored in two arrays: one for     The components of the where clause are stored in two arrays: one for
     operands and one for operators (these are placed in proper order by the     operands and one for operators (these are placed in proper order by the
     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 getPropertyNameCount() const      Uint32 getSelectPropertyNameCount() const;
     {  
         return _propertyNames.size();  
     }  
  
     /** Gets the i-th 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& getPropertyName(Uint32 i)      const CIMName& getSelectPropertyName(Uint32 i) const;
     {  
         return _propertyNames[i];  
     }  
  
     /** Appends a property name to the property name list. This user should      /**
           Returns a CIMPropertyList containing the selected properties.
           The list is NULL if the query selects all properties (SELECT * FROM...).
       */
       const CIMPropertyList getSelectPropertyList() const;
   
       /** 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 appendPropertyName(const String& x)      void appendSelectPropertyName(const CIMName& x);
     {  
         _propertyNames.append(x);      /** Returns the number of unique property names from the where clause.
     }      */
       Uint32 getWherePropertyNameCount() const;
   
       /** Gets the i-th unique property appearing in the where clause.
       */
       const CIMName& getWherePropertyName(Uint32 i) const;
   
       /**
           Returns a CIMPropertyList containing the unique properties used in the
           WHERE clause
       */
       const CIMPropertyList getWherePropertyList() const;
   
       /** 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.
   
           @param x name of the property.
           @return false if a property with that name already exists.
       */
       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* symbolTable) const;      Boolean evaluateWhereClause(const WQLPropertySource* source) const;
   
       /** Inspect an instance and remove properties not listed in Select projection.
       */
       void applyProjection(CIMInstance& inst) throw (Exception);
       void applyProjection(CIMObject& inst);
  
     /** 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;
  
     //      Boolean evaluate(const CIMInstance& inCI);
     // The name of the target class. For example:  
     //  
     //     SELECT *  
     //     FROM TargetClass  
     //     WHERE ...  
     //  
  
     String _className;      void validate() throw (Exception);
  
     //      CIMPropertyList getPropertyList(const CIMObjectPath& inClassName = CIMObjectPath());
     // The list of property names being selected. For example, see "firstName",  
     // and "lastName" below.  
     //  
     //     SELECT firstName, lastName  
     //     FROM TargetClass  
     //     WHERE ...  
     //  
  
     Array<String> _propertyNames;      Array<CIMObjectPath> getClassPathList();
  
     //  private:
     // 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;      WQLSelectStatementRep* _rep;
  
     //      //void f() const { }
     // 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;      friend class CMPI_Wql2Dnf;
 }; };
  
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END

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