← Back to branch summary

~juan457/+junk/zorba

« back to all changes in this revision

Viewing changes to src/runtime/indexing/doc_indexer.cpp

  • Committer: Tarmac
  • Author(s): Markos Zaharioudakis
  • Date: 2012-07-12 17:29:55 UTC
  • mfrom: (10870.4.9 index-maintenance)
  • Revision ID: tarmac-20120712172955-zju6u2p3v102mg43
Incremental maintenance for general indexes. Approved: Markos Zaharioudakis

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/runtime/indexing/doc_indexer.cpp
33
33
/*******************************************************************************
34
34
 
35
35
********************************************************************************/
36
 
DocIndexer::DocIndexer(csize numColumns, PlanIterator* plan, store::Item* varName)
 
36
DocIndexer::DocIndexer(
 
37
    bool general,
 
38
    csize numColumns,
 
39
    PlanIterator* plan,
 
40
    store::Item* varName)
37
41
  :
 
42
  theIsGeneral(general),
38
43
  theNumColumns(numColumns),
39
44
  theIndexerPlan(plan),
40
45
  theNodeVarName(varName),
81
86
  store::Item_t tmp = docNode;
82
87
  theDctx->set_variable(theNodeVarId, theNodeVarName, QueryLoc::null, tmp);
83
88
 
84
 
  csize numEntries = delta.size();
85
89
  store::Item_t domainNode;
86
 
  store::IndexKey* key = NULL;
87
90
 
88
91
  try
89
92
  {
90
 
    while (thePlanWrapper->next(domainNode))
 
93
    if (theIsGeneral)
91
94
    {
92
 
      key = new store::IndexKey(theNumColumns);
93
 
 
94
 
      //std::cout << domainNode.getp() << "  " << key << std::endl;
95
 
 
96
 
      for (csize i = 0; i < theNumColumns; ++i)
 
95
      if (thePlanWrapper->next(domainNode))
97
96
      {
98
 
        if (!thePlanWrapper->next((*key)[i]))
99
 
          throw ZORBA_EXCEPTION(zerr::ZXQP0003_INTERNAL_ERROR,
100
 
          ERROR_PARAMS(ZED(IncompleteKeyInIndexRefresh)));
 
97
        store::Item_t key;
 
98
        bool more = true;
 
99
 
 
100
        while (more)
 
101
        {
 
102
          assert(domainNode->isNode());
 
103
 
 
104
          while ((more = thePlanWrapper->next(key)))
 
105
          {
 
106
            if (key->isNode())
 
107
            {
 
108
              domainNode.transfer(key);
 
109
              break;
 
110
            }
 
111
 
 
112
            store::Item_t node = domainNode;
 
113
            delta.addGeneralPair(node, key);
 
114
          }
 
115
        }
101
116
      }
 
117
    }
 
118
    else
 
119
    {
 
120
      store::IndexKey* key = NULL;
 
121
 
 
122
      //std::cout << "Computing value index delta" << std::endl;
 
123
 
 
124
      try
 
125
      {
 
126
        while (thePlanWrapper->next(domainNode))
 
127
        {
 
128
          key = new store::IndexKey(theNumColumns);
 
129
 
 
130
          for (csize i = 0; i < theNumColumns; ++i)
 
131
          {
 
132
            if (!thePlanWrapper->next((*key)[i]))
 
133
            {
 
134
              throw ZORBA_EXCEPTION(zerr::ZXQP0003_INTERNAL_ERROR,
 
135
              ERROR_PARAMS(ZED(IncompleteKeyInIndexRefresh)));
 
136
            }
 
137
          }
102
138
      
103
 
      delta.resize(numEntries + 1);
104
 
      delta[numEntries].first.transfer(domainNode); 
105
 
      delta[numEntries].second = key;
106
 
      key = NULL;
107
 
      ++numEntries;
 
139
          /*
 
140
          std::cout << "[ node: " << domainNode.getp()
 
141
                    << " , key: " << key
 
142
                    << " , keyval: " << (*key)[0]->getStringValue()
 
143
                    << " ]" << std::endl;
 
144
          */
 
145
          delta.addValuePair(domainNode, key);
 
146
          key = NULL;
 
147
        }
 
148
 
 
149
        //std::cout << std::endl;
 
150
      }
 
151
      catch(...)
 
152
      {
 
153
        if (key != NULL)
 
154
          delete key;
 
155
 
 
156
        throw;
 
157
      }
108
158
    }
109
159
  }
110
160
  catch(...)
111
161
  {
112
 
    if (key != NULL)
113
 
      delete key;
114
 
 
115
 
    for (ulong i = 0; i < delta.size(); ++i)
116
 
    {
117
 
      delete delta[i].second;
118
 
    }
 
162
    delta.clear();
119
163
 
120
164
    theDctx->unset_variable(theNodeVarId, theNodeVarName, QueryLoc::null);
121
165