XQQuery.hpp

Go to the documentation of this file.

/*
 * Copyright (c) 2001, 2008,
 *     DecisionSoft Limited. All rights reserved.
 * Copyright (c) 2004, 2018 Oracle and/or its affiliates. All rights reserved.
 *     
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#ifndef XQQUERY_HPP
#define XQQUERY_HPP

#include <xqilla/framework/XQillaExport.hpp>
#include <vector>
#include <string>
#include <xercesc/util/XMemory.hpp>
#include <xercesc/sax/InputSource.hpp>
#include <xqilla/runtime/ResultImpl.hpp>
#include <xqilla/context/StaticContext.hpp>

#include <xercesc/util/RefHashTableOf.hpp>

class DynamicContext;
class XQUserFunction;
class XQGlobalVariable;
class XQQuery;
class DelayedModule;
class DelayedFuncFactory;
class StaticTyper;

typedef std::vector<XQGlobalVariable*, XQillaAllocator<XQGlobalVariable*> > GlobalVariables;
typedef std::vector<XQQuery*, XQillaAllocator<XQQuery*> > ImportedModules;
typedef std::vector<DelayedFuncFactory*, XQillaAllocator<DelayedFuncFactory*> > DelayedFunctions;

typedef XERCES_CPP_NAMESPACE_QUALIFIER RefHashTableOf<XQQuery> ModuleMap;

class XQILLA_API ModuleCache : public XERCES_CPP_NAMESPACE_QUALIFIER XMemory
{
public:
  ModuleCache(XERCES_CPP_NAMESPACE_QUALIFIER MemoryManager *mm);

  void put(XQQuery *module);
  XQQuery *getByURI(const XMLCh *uri) const;
  XQQuery *getByNamespace(const XMLCh *ns) const;

  ModuleMap byURI_;
  ModuleMap byNamespace_;
  ImportedModules ordered_;
};

class XQILLA_API XQQuery : public XERCES_CPP_NAMESPACE_QUALIFIER XMemory
{
public:
  ~XQQuery();

        // @{

  DynamicContext *createDynamicContext(XERCES_CPP_NAMESPACE_QUALIFIER MemoryManager *memMgr =
                                       XERCES_CPP_NAMESPACE_QUALIFIER XMLPlatformUtils::fgMemoryManager) const;

  Result execute(DynamicContext* context) const;

  Result execute(const Item::Ptr &contextItem, DynamicContext *context) const;

  Result execute(const XMLCh *templateQName, DynamicContext *context) const;

  void execute(EventHandler *events, DynamicContext* context) const;

  void execute(EventHandler *events, const Item::Ptr &contextItem, DynamicContext *context) const;

  void execute(EventHandler *events, const XMLCh *templateQName, DynamicContext *context) const;

  void staticResolution();

  void staticTyping(StaticTyper *styper = 0);
  bool staticTypingOnce(StaticTyper *styper = 0);


  // @{

  const XMLCh* getQueryText() const { return m_szQueryText; }
  void setQueryText(const XMLCh *v);

  std::string getQueryPlan() const;


  // @{

  ASTNode* getQueryBody() const;
  void setQueryBody(ASTNode* query);

  void addFunction(XQUserFunction* fnDef);
  const UserFunctions &getFunctions() const { return m_userDefFns; }

  void addDelayedFunction(const XMLCh *uri, const XMLCh *name, size_t numArgs,
                          const XMLCh *functionDeclaration, bool isPrivate = false,
                          int line = 1, int column = 1);
  void addDelayedFunction(const XMLCh *uri, const XMLCh *name, size_t numArgs,
                          const char *functionDeclaration, bool isPrivate = false,
                          int line = 1, int column = 1);
  const DelayedFunctions &getDelayedFunctions() const { return m_delayedFunctions; }

  void addVariable(XQGlobalVariable* varDef);
  const GlobalVariables &getVariables() const { return m_userDefVars; }

  const ImportedModules &getImportedModules() const { return m_importedModules; }

  ModuleCache *getModuleCache() const { return m_moduleCache; }
  bool isModuleCacheOwned() const { return m_moduleCacheOwned; }

  const XMLCh* getFile() const { return m_szCurrentFile; }

  void setFile(const XMLCh* file);

  bool getVersion3() const { return m_version3; }
  void setVersion3(bool v) { m_version3 = v; }

  const DynamicContext *getStaticContext() const { return m_context; }

  XQQuery *getNext() const { return m_next; }
  void setNext(XQQuery *n) { m_next = n; }


  // @{

  void setIsLibraryModule(bool bIsModule=true);
  bool getIsLibraryModule() const;
  void setModuleTargetNamespace(const XMLCh* uri);
  const XMLCh* getModuleTargetNamespace() const;
  void importModule(const XMLCh* szUri, VectorOfStrings* locations, const LocationInfo *location);
  void importModule(XQQuery *module);

  XQQuery *findModuleForVariable(const XMLCh *uri, const XMLCh *name);
  XQQuery *findModuleForFunction(const XMLCh *uri, const XMLCh *name, int numArgs);


private:
  XQQuery(DynamicContext *context, bool contextOwned, ModuleCache *moduleCache,
          XERCES_CPP_NAMESPACE_QUALIFIER MemoryManager *memMgr);

  XQQuery(const XQQuery &);
  XQQuery &operator=(const XQQuery &);

  XQQuery *parseModule(const XMLCh *ns, const XMLCh *at, const LocationInfo *location) const;
  void executeProlog(DynamicContext *context) const;

private:
  XERCES_CPP_NAMESPACE_QUALIFIER MemoryManager* m_memMgr;

  DynamicContext *m_context;
  bool m_contextOwned;

  ASTNode* m_query;

  bool m_bIsLibraryModule;
  const XMLCh* m_szTargetNamespace;
  const XMLCh* m_szQueryText;
  const XMLCh* m_szCurrentFile;

  UserFunctions m_userDefFns;
  DelayedFunctions m_delayedFunctions;
  GlobalVariables m_userDefVars;
  ImportedModules m_importedModules;

  ModuleCache *m_moduleCache;
  bool m_moduleCacheOwned;

  bool m_version3;

  enum { BEFORE, DURING, AFTER } m_staticTyped;

  // The next module with the same target namespace
  XQQuery *m_next;

  friend class QueryResult;
  friend class XQilla;
  friend class DelayedModule;
};

#endif