cqlselectstatementrep.cpp

Pegasus is an open-source implementationof the DMTF CIM and WBEM standards. It is designed to be por

        if (!containsProperty(ids[1].getName(), reqProps))
        {
          reqProps.append(ids[1].getName());
        }
      }
      else
      {
        PEG_TRACE_STRING (TRC_CQL, Tracer::LEVEL4,"scoping class is NOT a superclass");

        // Scoping class is not superclass of class passed in.
        // Save this information.
        unmatchedScopes.append(scopingClass);
      }
    }  // end else scoping class not == class passed in
  }  // end if first id is scoped
  else
  {
    // The 2nd chain element is an unscoped property
    // Check if it is wildcarded
    if (ids[1].isWildcard())
    {
      // Wildcard.
      // If the class passed in is the FROM class, then
      // all properties are required on the class passed in.
      CIMName fromClassName = _ctx->getFromList()[0].getName();
      if (fromClassName == className)
      {
        PEG_TRACE_STRING (TRC_CQL, Tracer::LEVEL4,"wildcard and = FROM");
        PEG_METHOD_EXIT();
        return true;
      }

      // Add all the properties on the FROM class to
      // the required property list.
      CIMClass fromClass = _ctx->getClass(fromClassName);
      for (Uint32 n = 0; n < fromClass.getPropertyCount(); n++)
      {
        // Add to the required property list if not already there.
        if (!containsProperty(fromClass.getProperty(n).getName(), reqProps))
        {
          reqProps.append(fromClass.getProperty(n).getName());
        }
      }

      PEG_METHOD_EXIT();
      return false;
    }

    // Implementation note:
    // Since this API assumes that the class passed in
    // is the FROM class or a subclass of the FROM class,
    // AND validateProperties can be called to check if
    // unscoped properties are on the FROM class,
    // we can just add the required property because
    // it is assumed to be on the FROM class.

    // Add to the required property list if not already there.
    if (!containsProperty(ids[1].getName(), reqProps))
    {
      reqProps.append(ids[1].getName());
    }
  }

  // Indicate the required property is not a wildcard
  PEG_METHOD_EXIT();
  return false;
}

Array<CQLChainedIdentifier> CQLSelectStatementRep::getSelectChainedIdentifiers()
{
  PEG_METHOD_ENTER (TRC_CQL, "CQLSelectStatementRep::getSelectChainedIdentifiers");

  if (!_contextApplied)
    applyContext();

  PEG_METHOD_EXIT();

  return _selectIdentifiers;
}

Array<CQLChainedIdentifier> CQLSelectStatementRep::getWhereChainedIdentifiers()
{
  PEG_METHOD_ENTER (TRC_CQL, "CQLSelectStatementRep::getWhereChainedIdentifiers");

  if(_ctx == NULL)
  {
    PEG_TRACE_STRING (TRC_CQL, Tracer::LEVEL4,"null QC");
    PEG_METHOD_EXIT();
    MessageLoaderParms parms("CQL.CQLSelectStatementRep.QUERY_CONTEXT_IS_NULL",
                             "Trying to process a query with a NULL Query Context.");
    throw CQLRuntimeException(parms);
  }

  if (!_contextApplied)
    applyContext();

  Array<QueryChainedIdentifier> qChainIds = _ctx->getWhereList();
  Array<CQLChainedIdentifier> cqlChainIds;
  for (Uint32 i = 0; i < qChainIds.size(); i++)
  {
    Array<QueryIdentifier> qSubs = qChainIds[i].getSubIdentifiers();
    CQLChainedIdentifier cqlChainId;
    for (Uint32 j = 0; j < qSubs.size(); j++)
    {
      cqlChainId.append(qSubs[j]);
    }

    cqlChainIds.append(cqlChainId);
  }

  PEG_METHOD_EXIT();

  return cqlChainIds;
}

Boolean CQLSelectStatementRep::containsProperty(const CIMName& name,
                                                const Array<CIMName>& props)
{
  PEG_METHOD_ENTER (TRC_CQL, "CQLSelectStatementRep::containsProperty");

  for (Uint32 i = 0; i < props.size(); i++)
  {
    if (props[i] == name)
    {
      PEG_METHOD_EXIT();
      return true;
    }
  }

  PEG_METHOD_EXIT();
  return false;
}

//
// Checks if the classname passed in is the FROM class, or
// a subclass of the FROM class
//
Boolean CQLSelectStatementRep::isFromChild(const CIMName& className)
{
  PEG_METHOD_ENTER (TRC_CQL, "CQLSelectStatementRep::isFromChild");

  QueryContext::ClassRelation rel =
    _ctx->getClassRelation(_ctx->getFromList()[0].getName(), className);

  PEG_METHOD_EXIT();
  return (rel == QueryContext::SAMECLASS || rel == QueryContext::SUBCLASS) ? true : false;
}

void CQLSelectStatementRep::appendClassPath(const CQLIdentifier& inIdentifier)
{
  PEG_METHOD_ENTER (TRC_CQL, "CQLSelectStatementRep::appendClassPath");

  if(_ctx == NULL)
  {
    PEG_TRACE_STRING (TRC_CQL, Tracer::LEVEL4,"null QC");
    PEG_METHOD_EXIT();
    MessageLoaderParms parms("CQL.CQLSelectStatementRep.QUERY_CONTEXT_IS_NULL",
                             "Trying to process a query with a NULL Query Context.");
    throw QueryValidationException(parms);
  }
  _ctx->insertClassPath(inIdentifier);

  PEG_METHOD_EXIT();
}

void CQLSelectStatementRep::setPredicate(const CQLPredicate& inPredicate)
{
  PEG_METHOD_ENTER (TRC_CQL, "CQLSelectStatementRep::setPredicate");
  _predicate = inPredicate;
  PEG_METHOD_EXIT();
}

CQLPredicate CQLSelectStatementRep::getPredicate() const
{
  PEG_METHOD_ENTER (TRC_CQL, "CQLSelectStatementRep::getPredicate");
  return _predicate;
}

void CQLSelectStatementRep::insertClassPathAlias(const CQLIdentifier& inIdentifier,
                                                 String inAlias)
{
  PEG_METHOD_ENTER (TRC_CQL, "CQLSelectStatementRep::insertClassPathAlias");

  if(_ctx == NULL)
  {
    PEG_TRACE_STRING (TRC_CQL, Tracer::LEVEL4,"null QC");
    PEG_METHOD_EXIT();
    MessageLoaderParms parms("CQL.CQLSelectStatementRep.QUERY_CONTEXT_IS_NULL",
                             "Trying to process a query with a NULL Query Context.");
    throw QueryValidationException(parms);
  }
  _ctx->insertClassPath(inIdentifier,inAlias);

  PEG_METHOD_EXIT();
}

void CQLSelectStatementRep::appendSelectIdentifier(const CQLChainedIdentifier& x)
{
  PEG_METHOD_ENTER (TRC_CQL, "CQLSelectStatementRep::appendSelectIdentifier");
  _selectIdentifiers.append(x);
  PEG_METHOD_EXIT();
}

void CQLSelectStatementRep::applyContext()
{
  PEG_METHOD_ENTER (TRC_CQL, "CQLSelectStatementRep::applyContext");

  if(_ctx == NULL)
  {
    PEG_TRACE_STRING (TRC_CQL, Tracer::LEVEL4,"null QC");
    PEG_METHOD_EXIT();
    MessageLoaderParms parms("CQL.CQLSelectStatementRep.QUERY_CONTEXT_IS_NULL",
                             "Trying to process a query with a NULL Query Context.");
    // throw syntax error to be consistent
    throw CQLSyntaxErrorException(parms);
  }

  for (Uint32 i = 0; i < _selectIdentifiers.size(); i++)
  {
    _selectIdentifiers[i].applyContext(*_ctx);
    checkWellFormedIdentifier(_selectIdentifiers[i], true);
  }

  if (hasWhereClause())
  {
    _predicate.applyContext(*_ctx);

    // Note: must be after call to predicate's applyContext
    Array<QueryChainedIdentifier> _whereIdentifiers = _ctx->getWhereList();
    for (Uint32 i = 0; i < _whereIdentifiers.size(); i++)
    {
      checkWellFormedIdentifier(_whereIdentifiers[i], false);
    }
  }

  _contextApplied = true;
  PEG_METHOD_EXIT();
}

void CQLSelectStatementRep::checkWellFormedIdentifier(const QueryChainedIdentifier& chainId,
                                                      Boolean isSelectListId)
{
  PEG_METHOD_ENTER (TRC_CQL, "CQLSelectStatementRep::checkWellFormedIdentifier");

  // This function assumes that applyContext has been called.
  Array<QueryIdentifier> ids = chainId.getSubIdentifiers();

  if (ids.size() == 0)
  {
    PEG_METHOD_EXIT();
    MessageLoaderParms parms("CQL.CQLSelectStatementRep.EMPTY_CHAIN",
                             "An empty chained identifier was found.");
    throw CQLSyntaxErrorException(parms);
  }

  PEG_TRACE_STRING (TRC_CQL, Tracer::LEVEL4,"chain =" + chainId.toString());

  if (ids.size() == 1 && isSelectListId)
  {
    // Single element chain ids are not allow in the select list.
    // The select list can only have properties.
    PEG_METHOD_EXIT();
    MessageLoaderParms parms("CQL.CQLSelectStatementRep.SINGLE_CHID_IN_SELECT",
                             "A property on the FROM class must be selected.");
    throw CQLSyntaxErrorException(parms);
  }

  if (ids[0].isScoped()
      || ids[0].isWildcard()
      || ids[0].isSymbolicConstant()
      || ids[0].isArray())
  {
    // The first identifier must be a classname (it could be the FROM class, or
    // some other class for the right side of ISA)
    PEG_METHOD_EXIT();
    MessageLoaderParms parms("CQL.CQLSelectStatementRep.FIRST_ID_ILLEGAL",
                             "The chained identifier $0 is illegal.",
                             chainId.toString());
    throw CQLSyntaxErrorException(parms);
  }

  Uint32 startingPos = 1;
  for (Uint32 pos = startingPos; pos < ids.size(); pos++)
  {
    if (ids[pos].isArray() && isSelectListId)
    {
      PEG_METHOD_EXIT();
      MessageLoaderParms parms("CQL.CQLSelectStatementRep.ARRAY_IN_SELECT",
                             "The identifier $0 of $1 in the SELECT list cannot use an array index.",
                             ids[pos].toString(), chainId.toString());
      throw CQLSyntaxErrorException(parms);
    }

    if (ids[pos].isSymbolicConstant() && isSelectListId)
    {
      PEG_METHOD_EXIT();
      MessageLoaderParms parms("CQL.CQLSelectStatementRep.SYMCONST_IN_SELECT",
                             "The identifier $0 of $1 in the SELECT list cannot use a symbolic constant.",
                             ids[pos].toString(), chainId.toString());
      throw CQLSyntaxErrorException(parms);
    }

    if (ids[pos].isSymbolicConstant() && pos != (ids.size() -1))
    {
      PEG_METHOD_EXIT();
      MessageLoaderParms parms("CQL.CQLSelectStatementRep.SYMCONST_NOT_LAST",
                             "The symbolic constant identifier $0 of $1 must be the last element.",
                             ids[pos].toString(), chainId.toString());
      throw CQLSyntaxErrorException(parms);
    }

    if (ids[pos].isWildcard())
    {
      if ( !isSelectListId)
      {
        PEG_METHOD_EXIT();
        MessageLoaderParms parms("CQL.CQLSelectStatementRep.WILD_IN_WHERE",
                             "The identifier $0 of $1 in the WHERE list cannot use a wildcard.",
                             ids[pos].toString(), chainId.toString());
        throw CQLSyntaxErrorException(parms);
      }

      if ( pos != ids.size() - 1)
      {
        PEG_METHOD_EXIT();
        MessageLoaderParms parms("CQL.CQLSelectStatementRep.WILD_NOT_END",
                             "The wildcard identifier $0 of $1 must be the last element.",
                             ids[pos].toString(), chainId.toString());
        throw CQLSyntaxErrorException(parms);
      }
    }

    if (pos > startingPos && !ids[pos].isWildcard())
    {
      if (!ids[pos].isScoped())
      {
        PEG_METHOD_EXIT();
        MessageLoaderParms parms("CQL.CQLSelectStatementRep.EMB_PROP_NOT_SCOPED",
                             "The identifier $0 of $1 must use the scope operator.",
                             ids[pos].toString(), chainId.toString());
        throw CQLSyntaxErrorException(parms);
      }
    }
  }

  PEG_METHOD_EXIT();
}

void CQLSelectStatementRep::normalizeToDOC()
{
  PEG_METHOD_ENTER (TRC_CQL, "CQLSelectStatementRep::normalizeToDOC");

  if (!_contextApplied)
    applyContext();

  if(_hasWhereClause){
    Cql2Dnf DNFer(_predicate);
    _predicate = DNFer.getDnfPredicate();
  }

  PEG_METHOD_EXIT();
}

String CQLSelectStatementRep::toString()
{
  PEG_METHOD_ENTER (TRC_CQL, "CQLSelectStatementRep::toString");

  if(_ctx == NULL)
  {
    PEG_TRACE_STRING (TRC_CQL, Tracer::LEVEL4,"null QC");
    PEG_METHOD_EXIT();
    MessageLoaderParms parms("CQL.CQLSelectStatementRep.QUERY_CONTEXT_IS_NULL",
                             "Trying to process a query with a NULL Query Context.");
    throw CQLRuntimeException(parms);
  }

  String s("SELECT ");
  for(Uint32 i = 0; i < _selectIdentifiers.size(); i++){
    if((i > 0) && (i < _selectIdentifiers.size()))
    {
      s.append(",");
    }
    s.append(_selectIdentifiers[i].toString());
  }

  s.append(" ");
  s.append(_ctx->getFromString());

  if(_hasWhereClause){
    s.append(" WHERE ");
    s.append(_predicate.toString());
  }

  PEG_METHOD_EXIT();
  return s;
}

void CQLSelectStatementRep::setHasWhereClause()
{
  PEG_METHOD_ENTER (TRC_CQL, "CQLSelectStatementRep::setHasWhereClause");
  _hasWhereClause = true;
  PEG_METHOD_EXIT();
}

Boolean CQLSelectStatementRep::hasWhereClause()
{
  PEG_METHOD_ENTER (TRC_CQL, "CQLSelectStatementRep::hasWhereClause");
  return _hasWhereClause;
}

void  CQLSelectStatementRep::clear()
{
  PEG_METHOD_ENTER (TRC_CQL, "CQLSelectStatementRep::clear");

    if(_ctx == NULL)
    {
     PEG_TRACE_STRING (TRC_CQL, Tracer::LEVEL4,"null QC");
     PEG_METHOD_EXIT();
     MessageLoaderParms parms("CQL.CQLSelectStatementRep.QUERY_CONTEXT_IS_NULL",
                              "Trying to process a query with a NULL Query Context.");
     throw CQLRuntimeException(parms);
    }

   _ctx->clear();
   _hasWhereClause = false;
   _contextApplied = false;
   _predicate = CQLPredicate();
   _selectIdentifiers.clear();

   PEG_METHOD_EXIT();
}

PEGASUS_NAMESPACE_END