Serializer.cpp
Go to the documentation of this file.
1 /* Copyright (C) 2008 National Institute For Space Research (INPE) - Brazil.
2 
3  This file is part of the TerraLib - a Framework for building GIS enabled applications.
4 
5  TerraLib is free software: you can redistribute it and/or modify
6  it under the terms of the GNU Lesser General Public License as published by
7  the Free Software Foundation, either version 3 of the License,
8  or (at your option) any later version.
9 
10  TerraLib is distributed in the hope that it will be useful,
11  but WITHOUT ANY WARRANTY; without even the implied warranty of
12  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13  GNU Lesser General Public License for more details.
14 
15  You should have received a copy of the GNU Lesser General Public License
16  along with TerraLib. See COPYING. If not, write to
17  TerraLib Team at <terralib-team@terralib.org>.
18  */
19 
20 /*!
21  \file terralib/dataaccess/serialization/xml/DataSetType.cpp
22 
23  \brief Support for DataSetType serialization.
24 */
25 
26 // TerraLib
27 #include "../../../Version.h"
28 #include "../../../common/BoostUtils.h"
29 #include "../../../common/PlatformUtils.h"
30 #include "../../../datatype/AbstractData.h"
31 #include "../../../datatype/Enums.h"
32 #include "../../../datatype/serialization/xml/Serializer.h"
33 #include "../../../datatype/StringProperty.h"
34 #include "../../../datatype/Utils.h"
35 #include "../../../geometry/Geometry.h"
36 #include "../../../geometry/WKTReader.h"
37 #include "../../../xml/AbstractWriter.h"
38 #include "../../../xml/AbstractWriterFactory.h"
39 #include "../../../xml/Reader.h"
40 #include "../../../xml/ReaderFactory.h"
41 #include "../../dataset/DataSetType.h"
42 #include "../../datasource/DataSourceCapabilities.h"
43 #include "../../datasource/DataSourceCatalog.h"
44 #include "../../datasource/DataSourceInfo.h"
45 #include "../../datasource/DataSourceInfoManager.h"
46 #include "../../query/BinaryFunction.h"
47 #include "../../query/BinaryOpEncoder.h"
48 #include "../../query/DataSetName.h"
49 #include "../../query/Distinct.h"
50 #include "../../query/Expression.h"
51 #include "../../query/Field.h"
52 #include "../../query/FromItem.h"
53 #include "../../query/Function.h"
54 #include "../../query/FunctionEncoder.h"
55 #include "../../query/GroupByItem.h"
56 #include "../../query/Having.h"
57 #include "../../query/Join.h"
58 #include "../../query/JoinConditionOn.h"
59 #include "../../query/JoinConditionUsing.h"
60 #include "../../query/Literal.h"
61 #include "../../query/LiteralDouble.h"
62 #include "../../query/LiteralGeom.h"
63 #include "../../query/LiteralInt16.h"
64 #include "../../query/LiteralInt32.h"
65 #include "../../query/LiteralInt64.h"
66 #include "../../query/LiteralString.h"
67 #include "../../query/OrderByItem.h"
68 #include "../../query/PropertyName.h"
69 #include "../../query/Select.h"
70 #include "../../query/SQLDialect.h"
71 #include "../../query/SQLFunctionEncoder.h"
72 #include "../../query/TemplateEncoder.h"
73 #include "../../query/UnaryOpEncoder.h"
74 #include "../../query/Where.h"
75 #include "../../Exception.h"
76 #include "Serializer.h"
77 
78 // STL
79 #include <cassert>
80 #include <fstream>
81 #include <memory>
82 
83 // Boost
84 #include <boost/algorithm/string/case_conv.hpp>
85 #include <boost/format.hpp>
86 #include <boost/lexical_cast.hpp>
87 #include <boost/algorithm/string/replace.hpp>
88 #include <boost/filesystem.hpp>
89 
90 void te::serialize::xml::ReadDataSourceInfo(const std::string& datasourcesFileName)
91 {
92  if(!boost::filesystem::is_regular_file(datasourcesFileName))
93  return;
94 
95  std::auto_ptr<te::xml::Reader> xmlReader(te::xml::ReaderFactory::make());
96 
97  xmlReader->read(datasourcesFileName);
98 
99  if(!xmlReader->next())
100  throw te::da::Exception((boost::format(TE_TR("Could not read data source information in file: %1%.")) % datasourcesFileName).str());
101 
102  if(xmlReader->getNodeType() != te::xml::START_ELEMENT)
103  throw te::da::Exception((boost::format(TE_TR("Error reading the document %1%, the start element wasn't found.")) % datasourcesFileName).str());
104 
105  if(xmlReader->getElementLocalName() != "DataSourceList")
106  throw te::da::Exception((boost::format(TE_TR("The first tag in the document %1% is not 'DataSourceList'.")) % datasourcesFileName).str());
107 
108  if(!xmlReader->next())
109  return;
110 
111  while((xmlReader->getNodeType() == te::xml::START_ELEMENT) &&
112  (xmlReader->getElementLocalName() == "DataSource"))
113  {
114  te::da::DataSourceInfoPtr ds(ReadDataSourceInfo(*xmlReader));
115  te::da::DataSourceInfoManager::getInstance().add(ds);
116  }
117 
118  return;
119 }
120 
121 te::da::DataSourceInfo* te::serialize::xml::ReadDataSourceInfo(te::xml::Reader& reader)
122 {
123  std::auto_ptr<te::da::DataSourceInfo> ds(new te::da::DataSourceInfo);
124 
125  ds->setId(reader.getAttr("id"));
126  ds->setType(reader.getAttr("type"));
127  ds->setAccessDriver(reader.getAttr("access_driver"));
128 
129  /* Title Element */
130  reader.next();
131  assert(reader.getNodeType() == te::xml::START_ELEMENT);
132  assert(reader.getElementLocalName() == "Title");
133  reader.next();
134  assert(reader.getNodeType() == te::xml::VALUE);
135  ds->setTitle(reader.getElementValue());
136  reader.next();
137  assert(reader.getNodeType() == te::xml::END_ELEMENT);
138 
139  /* Description Element */
140  reader.next();
141  assert(reader.getNodeType() == te::xml::START_ELEMENT);
142  assert(reader.getElementLocalName() == "Description");
143  reader.next();
144 
145  if(reader.getNodeType() == te::xml::VALUE)
146  {
147  ds->setDescription(reader.getElementValue());
148  reader.next();
149  }
150 
151  // if only white spaces
152  if (reader.getNodeType() == te::xml::WHITESPACE)
153  reader.next();
154 
155  assert(reader.getNodeType() == te::xml::END_ELEMENT);
156 
157  /* ConnectionInfo Element */
158  reader.next();
159  assert(reader.getNodeType() == te::xml::START_ELEMENT);
160  assert(reader.getElementLocalName() == "ConnectionInfo");
161 
162  std::map<std::string, std::string> conninfo;
163 
164  while(reader.next() &&
165  (reader.getNodeType() == te::xml::START_ELEMENT) &&
166  (reader.getElementLocalName() == "Parameter"))
167  {
168  // Parameter Name
169  reader.next();
170  assert(reader.getNodeType() == te::xml::START_ELEMENT);
171  assert(reader.getElementLocalName() == "Name");
172  reader.next();
173  assert(reader.getNodeType() == te::xml::VALUE);
174  std::string paramName = reader.getElementValue();
175  reader.next();
176  assert(reader.getNodeType() == te::xml::END_ELEMENT);
177 
178  // Parameter Value
179  reader.next();
180  assert(reader.getNodeType() == te::xml::START_ELEMENT);
181  assert(reader.getElementLocalName() == "Value");
182  reader.next();
183  assert(reader.getNodeType() == te::xml::VALUE);
184  std::string paramValue = reader.getElementValue();
185  reader.next();
186  assert(reader.getNodeType() == te::xml::END_ELEMENT);
187 
188  conninfo[paramName] = paramValue;
189 
190  reader.next();
191  assert(reader.getNodeType() == te::xml::END_ELEMENT);
192  }
193 
194  assert(reader.getNodeType() == te::xml::END_ELEMENT); // End of ConnectionInfo Element
195  reader.next();
196 
197  assert(reader.getNodeType() == te::xml::END_ELEMENT); // End of DataSource Element
198  reader.next();
199 
200  ds->setConnInfo(conninfo);
201 
202  return ds.release();
203 }
204 
205 void te::serialize::xml::Save(const std::string& fileName)
206 {
207  std::auto_ptr<te::xml::AbstractWriter> w(te::xml::AbstractWriterFactory::make());
208 
209  w->setURI(fileName);
210 
211  Save(*w.get());
212 }
213 
214 void te::serialize::xml::Save(te::xml::AbstractWriter& writer)
215 {
216  std::string schema_loc = te::common::FindInTerraLibPath("share/terralib/schemas/terralib/dataaccess/dataaccess.xsd");
217 
218  boost::replace_all(schema_loc, " ", "%20");
219 
220  schema_loc = "file:///" + schema_loc;
221 
222  writer.writeStartDocument("UTF-8", "no");
223 
224  writer.setRootNamespaceURI("http://www.terralib.org/schemas/dataaccess");
225 
226  writer.writeStartElement("te_da:DataSourceList");
227 
228  writer.writeAttribute("xmlns:xsd", "http://www.w3.org/2001/XMLSchema-instance");
229  writer.writeAttribute("xmlns:te_common", "http://www.terralib.org/schemas/common");
230  writer.writeAttribute("xmlns", "http://www.terralib.org/schemas/dataaccess");
231  writer.writeAttribute("xsd:schemaLocation", "http://www.terralib.org/schemas/dataaccess " + schema_loc);
232  writer.writeAttribute("version", TERRALIB_VERSION_STRING);
233  writer.writeAttribute("release", "2013-01-01");
234 
235  te::da::DataSourceInfoManager::iterator itBegin = te::da::DataSourceInfoManager::getInstance().begin();
236  te::da::DataSourceInfoManager::iterator itEnd = te::da::DataSourceInfoManager::getInstance().end();
237  te::da::DataSourceInfoManager::iterator it;
238 
239  for(it=itBegin; it!=itEnd; ++it)
240  {
241  bool ogrDsrc = it->second->getAccessDriver() == "OGR";
242 
243  writer.writeStartElement("te_da:DataSource");
244 
245  writer.writeAttribute("id", it->second->getId());
246  writer.writeAttribute("type", it->second->getType());
247  writer.writeAttribute("access_driver", it->second->getAccessDriver());
248 
249  writer.writeStartElement("te_da:Title");
250  writer.writeValue((!ogrDsrc) ? it->second->getTitle() : te::common::ConvertLatin1UTFString(it->second->getTitle()));
251  writer.writeEndElement("te_da:Title");
252 
253  writer.writeStartElement("te_da:Description");
254  writer.writeValue((!ogrDsrc) ? it->second->getDescription() : te::common::ConvertLatin1UTFString(it->second->getDescription()));
255  writer.writeEndElement("te_da:Description");
256 
257  writer.writeStartElement("te_da:ConnectionInfo");
258  std::map<std::string, std::string> info = it->second->getConnInfo();
259  std::map<std::string, std::string>::iterator conIt;
260 
261  for(conIt=info.begin(); conIt!=info.end(); ++conIt)
262  {
263  writer.writeStartElement("te_common:Parameter");
264 
265  writer.writeStartElement("te_common:Name");
266  writer.writeValue(conIt->first);
267  writer.writeEndElement("te_common:Name");
268 
269  writer.writeStartElement("te_common:Value");
270  writer.writeValue((ogrDsrc && (conIt->first == "URI" || conIt->first == "SOURCE")) ? te::common::ConvertLatin1UTFString(conIt->second) : conIt->second);
271  writer.writeEndElement("te_common:Value");
272 
273  writer.writeEndElement("te_common:Parameter");
274  }
275  writer.writeEndElement("te_da:ConnectionInfo");
276 
277  writer.writeEndElement("te_da:DataSource");
278  }
279 
280  writer.writeEndElement("te_da:DataSourceList");
281 
282  writer.writeToFile();
283 }
284 
285 te::da::DataSourceCatalog* te::serialize::xml::ReadDataSourceCatalog(te::xml::Reader& reader)
286 {
287  assert(reader.getNodeType() == te::xml::START_ELEMENT);
288  assert(reader.getElementLocalName() == "DataSourceCatalog");
289 
290  //reader.next();
291  //assert(reader.getNodeType() == te::xml::START_ELEMENT);
292  //assert(reader.getElementLocalName() == "Name");
293 
294  //reader.next();
295  //assert(reader.getNodeType() == te::xml::VALUE);
296 
297  reader.next();
298  assert(reader.getNodeType() == te::xml::START_ELEMENT);
299  assert(reader.getElementLocalName() == "DataSetTypes");
300 
301  reader.next();
302 
303  std::auto_ptr<te::da::DataSourceCatalog> catalog(new te::da::DataSourceCatalog);
304 
305  while(reader.getNodeType() == te::xml::START_ELEMENT &&
306  reader.getElementLocalName() == "DataSetType")
307  {
308  te::da::DataSetTypePtr dt(ReadDataSetType(reader));
309  catalog->add(dt);
310  }
311 
312  assert(reader.getNodeType() == te::xml::END_ELEMENT); // End of DataSetTypes Element
313  reader.next();
314 
315  assert(reader.getNodeType() == te::xml::END_ELEMENT); // End of DataSourceCatalog Element
316  reader.next();
317 
318  return catalog.release();
319 }
320 
321 void te::serialize::xml::Save(const te::da::DataSourceCatalog* catalog, const std::string& fileName)
322 {
323  std::auto_ptr<te::xml::AbstractWriter> w(te::xml::AbstractWriterFactory::make());
324  w->setURI(fileName);
325  Save(catalog, *w.get());
326 }
327 
328 void te::serialize::xml::Save(const te::da::DataSourceCatalog* catalog, te::xml::AbstractWriter& writer)
329 {
330  writer.writeStartDocument("UTF-8", "no");
331 
332  writer.writeStartElement("DataSourceCatalog");
333 
334  writer.writeAttribute("xmlns:xlink", "http://www.w3.org/1999/xlink");
335  writer.writeAttribute("xmlns:xsd", "http://www.w3.org/2001/XMLSchema-instance");
336  writer.writeAttribute("xmlns", "http://www.terralib.org/schemas/da");
337  writer.writeAttribute("xsd:schemaLocation", "http://www.terralib.org/schemas/da C:/Users/gribeiro/Documents/terralib5/trunk/myschemas/terralib/da/catalog.xsd");
338  writer.writeAttribute("version", "5.0.0");
339  writer.writeAttribute("release", "2011-01-01");
340 
341  writer.writeStartElement("DataSetTypes");
342 
343  const std::size_t ndatasets = catalog->getNumberOfDataSets();
344 
345  for(std::size_t i = 0; i < ndatasets; ++i)
346  Save(catalog->getDataSetType(i).get(), writer);
347 
348  writer.writeEndElement("DataSetTypes");
349 
350  writer.writeEndElement("DataSourceCatalog");
351 }
352 
353 te::da::DataSetType* te::serialize::xml::ReadDataSetType(te::xml::Reader& reader)
354 {
355  assert(reader.getNodeType() == te::xml::START_ELEMENT);
356  assert(reader.getElementLocalName() == "DataSetType");
357 
358  unsigned int id = reader.getAttrAsUInt32("id");
359  std::string name = reader.getAttr("name");
360  std::string title = reader.getAttr("title");
361 
362  reader.next();
363 
364  std::auto_ptr<te::da::DataSetType> dt(new te::da::DataSetType(name, id));
365 
366  dt->setTitle(title);
367 
368  while(reader.getNodeType() == te::xml::START_ELEMENT &&
369  reader.getElementLocalName() == "Property")
370  {
371  std::auto_ptr<te::dt::Property> p(ReadProperty(reader));
372  dt->add(p.release());
373  }
374 
375  assert(reader.getNodeType() == te::xml::END_ELEMENT); // End of DataSetType Element
376  reader.next();
377 
378  return dt.release();
379 }
380 
381 void te::serialize::xml::Save(const te::da::DataSetType* dt, te::xml::AbstractWriter& writer)
382 {
383  writer.writeStartElement("te_da:DataSetType");
384 
385  writer.writeAttribute("id", dt->getId());
386  writer.writeAttribute("name", dt->getName());
387  writer.writeAttribute("title", dt->getTitle());
388 
389  const std::size_t nprops = dt->size();
390 
391  for(std::size_t i = 0; i < nprops; ++i)
392  Save(*(dt->getProperty(i)), writer);
393 
394  writer.writeEndElement("te_da:DataSetType");
395 }
396 
397 te::common::AccessPolicy Convert2Terralib(std::string accessPolicy)
398 {
399  if(accessPolicy == "NO_ACCESS")
400  return te::common::NoAccess;
401  else if (accessPolicy == "R_ACCESS")
402  return te::common::RAccess;
403  else if(accessPolicy == "W_ACCESS")
404  return te::common::WAccess;
405  else if(accessPolicy == "RW_ACCESS")
406  return te::common::RWAccess;
407  else
408  return te::common::NoAccess;
409 }
410 
411 void te::serialize::xml::Read(const std::string& dialectFileName, te::da::DataSourceCapabilities& capabilities, te::da::SQLDialect& dialect)
412 {
413  std::auto_ptr<te::xml::Reader> xmlReader(te::xml::ReaderFactory::make());
414 
415  xmlReader->read(dialectFileName);
416 
417  if(!xmlReader->next())
418  throw te::da::Exception((boost::format(TE_TR("Could not read DataSourceCapabilities information in file: %1%.")) % dialectFileName).str());
419 
420  if(xmlReader->getNodeType() != te::xml::START_ELEMENT)
421  throw te::da::Exception((boost::format(TE_TR("Error reading the document %1%, the start element wasn't found.")) % dialectFileName).str());
422 
423  if(xmlReader->getElementLocalName() != "DataSourceCapabilities")
424  throw te::da::Exception((boost::format(TE_TR("The first tag in the document %1% is not 'DataSourceCapabilities'.")) % dialectFileName).str());
425 
426  xmlReader->next();
427  assert(xmlReader->getNodeType() == te::xml::START_ELEMENT);
428  assert(xmlReader->getElementLocalName() == "DataTypeCapabilities");
429 
430  te::da::DataTypeCapabilities dtc;
431 
432  while(xmlReader->next() &&
433  (xmlReader->getNodeType() == te::xml::START_ELEMENT) &&
434  (xmlReader->getElementLocalName() == "DataType"))
435  {
436  xmlReader->next();
437  assert(xmlReader->getNodeType() == te::xml::VALUE);
438 
439  dtc.setSupport(te::dt::Convert2Terralib(xmlReader->getElementValue()), true);
440 
441  xmlReader->next();
442  assert(xmlReader->getNodeType() == te::xml::END_ELEMENT);
443  }
444 
445  capabilities.setDataTypeCapabilities(dtc);
446 
447  assert(xmlReader->getNodeType() == te::xml::END_ELEMENT); // DataTypeCapabilities
448 
449  xmlReader->next();
450  assert(xmlReader->getNodeType() == te::xml::START_ELEMENT);
451  assert(xmlReader->getElementLocalName() == "QueryCapabilities");
452 
453  te::da::QueryCapabilities qc;
454 
455  xmlReader->next();
456  assert(xmlReader->getNodeType() == te::xml::START_ELEMENT);
457  assert(xmlReader->getElementLocalName() == "SQLDialect");
458 
459  xmlReader->next();
460  qc.setSupportSQLDialect(xmlReader->getElementValueAsBoolean());
461 
462  xmlReader->next();
463  assert(xmlReader->getNodeType() == te::xml::END_ELEMENT); // SQLDialect
464 
465  xmlReader->next();
466  assert(xmlReader->getNodeType() == te::xml::START_ELEMENT);
467  assert(xmlReader->getElementLocalName() == "SpatialSQLDialect");
468 
469  xmlReader->next();
470  qc.setSupportSpatialSQLDialect(xmlReader->getElementValueAsBoolean());
471 
472  xmlReader->next();
473  assert(xmlReader->getNodeType() == te::xml::END_ELEMENT); // SpatialSQLDialect
474 
475  xmlReader->next();
476  assert(xmlReader->getNodeType() == te::xml::START_ELEMENT);
477  assert(xmlReader->getElementLocalName() == "Insert");
478 
479  xmlReader->next();
480  assert(xmlReader->getNodeType() == te::xml::VALUE);
481  qc.setSupportInsert(xmlReader->getElementValueAsBoolean());
482 
483  xmlReader->next();
484  assert(xmlReader->getNodeType() == te::xml::END_ELEMENT); // Insert
485 
486  xmlReader->next();
487  assert(xmlReader->getNodeType() == te::xml::START_ELEMENT);
488  assert(xmlReader->getElementLocalName() == "Update");
489 
490  xmlReader->next();
491  assert(xmlReader->getNodeType() == te::xml::VALUE);
492  qc.setSupportUpdate(xmlReader->getElementValueAsBoolean());
493 
494  xmlReader->next();
495  assert(xmlReader->getNodeType() == te::xml::END_ELEMENT); // Update
496 
497  xmlReader->next();
498  assert(xmlReader->getNodeType() == te::xml::START_ELEMENT);
499  assert(xmlReader->getElementLocalName() == "Delete");
500 
501  xmlReader->next();
502  assert(xmlReader->getNodeType() == te::xml::VALUE);
503  qc.setSupportDelete(xmlReader->getElementValueAsBoolean());
504 
505  xmlReader->next();
506  assert(xmlReader->getNodeType() == te::xml::END_ELEMENT); // Delete
507 
508  xmlReader->next();
509  assert(xmlReader->getNodeType() == te::xml::START_ELEMENT);
510  assert(xmlReader->getElementLocalName() == "Create");
511 
512  xmlReader->next();
513  assert(xmlReader->getNodeType() == te::xml::VALUE);
514  qc.setSupportCreate(xmlReader->getElementValueAsBoolean());
515 
516  xmlReader->next();
517  assert(xmlReader->getNodeType() == te::xml::END_ELEMENT); // Create
518 
519  xmlReader->next();
520  assert(xmlReader->getNodeType() == te::xml::START_ELEMENT);
521  assert(xmlReader->getElementLocalName() == "Drop");
522 
523  xmlReader->next();
524  assert(xmlReader->getNodeType() == te::xml::VALUE);
525  qc.setSupportDrop(xmlReader->getElementValueAsBoolean());
526 
527  xmlReader->next();
528  assert(xmlReader->getNodeType() == te::xml::END_ELEMENT); // Drop
529 
530  xmlReader->next();
531  assert(xmlReader->getNodeType() == te::xml::START_ELEMENT);
532  assert(xmlReader->getElementLocalName() == "Alter");
533 
534  xmlReader->next();
535  assert(xmlReader->getNodeType() == te::xml::VALUE);
536  qc.setSupportAlter(xmlReader->getElementValueAsBoolean());
537 
538  xmlReader->next();
539  assert(xmlReader->getNodeType() == te::xml::END_ELEMENT); // Alter
540 
541  xmlReader->next();
542  assert(xmlReader->getNodeType() == te::xml::START_ELEMENT);
543  assert(xmlReader->getElementLocalName() == "Select");
544 
545  xmlReader->next();
546  assert(xmlReader->getNodeType() == te::xml::VALUE);
547  qc.setSupportSelect(xmlReader->getElementValueAsBoolean());
548 
549  xmlReader->next();
550  assert(xmlReader->getNodeType() == te::xml::END_ELEMENT); // Select
551 
552  xmlReader->next();
553  assert(xmlReader->getNodeType() == te::xml::START_ELEMENT);
554  assert(xmlReader->getElementLocalName() == "SelectInto");
555 
556  xmlReader->next();
557  assert(xmlReader->getNodeType() == te::xml::VALUE);
558  qc.setSupportSelectInto(xmlReader->getElementValueAsBoolean());
559 
560  xmlReader->next();
561  assert(xmlReader->getNodeType() == te::xml::END_ELEMENT); // SelectInto
562 
563  //----------------------------
564 
565  xmlReader->next();
566  assert(xmlReader->getNodeType() == te::xml::START_ELEMENT);
567  assert(xmlReader->getElementLocalName() == "SpatialTopologicOperators");
568 
569  while(xmlReader->next() &&
570  (xmlReader->getNodeType() == te::xml::START_ELEMENT) &&
571  (xmlReader->getElementLocalName() == "Function"))
572  {
573  te::da::SQLFunctionEncoder* sfe = 0;
574 
575  std::string fname = xmlReader->getAttr("name");
576 
577  qc.addSpatialTopologicOperator(fname);
578 
579  xmlReader->next();
580  assert(xmlReader->getNodeType() == te::xml::START_ELEMENT);
581 
582  std::string encoderType = xmlReader->getElementLocalName();
583 
584  if(encoderType == "FunctionEncoder")
585  {
586  std::string alias = xmlReader->getAttr(0);
587  sfe = new te::da::FunctionEncoder(alias);
588  }
589  else if(encoderType == "BinaryOpEncoder")
590  {
591  std::string alias = xmlReader->getAttr(0);
592  sfe = new te::da::BinaryOpEncoder(alias);
593  }
594  else if(encoderType == "UnaryOpEncoder")
595  {
596  std::string alias = xmlReader->getAttr(0);
597  sfe = new te::da::UnaryOpEncoder(alias);
598  }
599  else if(encoderType == "TemplateEncoder")
600  {
601  std::string alias = xmlReader->getAttr(0);
602  std::string temp = xmlReader->getAttr(1);
603  sfe = new te::da::TemplateEncoder(alias, temp);
604  }
605  else
606  {
607  throw te::da::Exception(TE_TR("Unsupported encoder type!"));
608  }
609 
610  dialect.insert(fname, sfe);
611 
612  xmlReader->next();
613 
614  assert(xmlReader->getNodeType() == te::xml::END_ELEMENT);
615 
616  xmlReader->next();
617  }
618 
619  assert(xmlReader->getNodeType() == te::xml::END_ELEMENT); // SpatialTopologicOperators
620 
621  xmlReader->next();
622  assert(xmlReader->getNodeType() == te::xml::START_ELEMENT);
623  assert(xmlReader->getElementLocalName() == "SpatialMetricOperators");
624 
625  while(xmlReader->next() &&
626  (xmlReader->getNodeType() == te::xml::START_ELEMENT) &&
627  (xmlReader->getElementLocalName() == "Function"))
628  {
629  te::da::SQLFunctionEncoder* sfe = 0;
630 
631  std::string fname = xmlReader->getAttr("name");
632 
633  qc.addSpatialMetricOperator(fname);
634 
635  xmlReader->next();
636  assert(xmlReader->getNodeType() == te::xml::START_ELEMENT);
637 
638  std::string encoderType = xmlReader->getElementLocalName();
639 
640  if(encoderType == "FunctionEncoder")
641  {
642  std::string alias = xmlReader->getAttr(0);
643  sfe = new te::da::FunctionEncoder(alias);
644  }
645  else if(encoderType == "BinaryOpEncoder")
646  {
647  std::string alias = xmlReader->getAttr(0);
648  sfe = new te::da::BinaryOpEncoder(alias);
649  }
650  else if(encoderType == "UnaryOpEncoder")
651  {
652  std::string alias = xmlReader->getAttr(0);
653  sfe = new te::da::UnaryOpEncoder(alias);
654  }
655  else if(encoderType == "TemplateEncoder")
656  {
657  std::string alias = xmlReader->getAttr(0);
658  std::string temp = xmlReader->getAttr(1);
659  sfe = new te::da::TemplateEncoder(alias, temp);
660  }
661  else
662  {
663  throw te::da::Exception(TE_TR("Unsupported encoder type!"));
664  }
665 
666  dialect.insert(fname, sfe);
667 
668  xmlReader->next();
669 
670  assert(xmlReader->getNodeType() == te::xml::END_ELEMENT);
671 
672  xmlReader->next();
673  }
674 
675  assert(xmlReader->getNodeType() == te::xml::END_ELEMENT); // SpatialMetricOperators
676 
677  xmlReader->next();
678  assert(xmlReader->getNodeType() == te::xml::START_ELEMENT);
679  assert(xmlReader->getElementLocalName() == "SpatialNewGeomOperators");
680 
681  while(xmlReader->next() &&
682  (xmlReader->getNodeType() == te::xml::START_ELEMENT) &&
683  (xmlReader->getElementLocalName() == "Function"))
684  {
685  te::da::SQLFunctionEncoder* sfe = 0;
686 
687  std::string fname = xmlReader->getAttr("name");
688 
689  qc.addSpatialNewGeomOperator(fname);
690 
691  xmlReader->next();
692  assert(xmlReader->getNodeType() == te::xml::START_ELEMENT);
693 
694  std::string encoderType = xmlReader->getElementLocalName();
695 
696  if(encoderType == "FunctionEncoder")
697  {
698  std::string alias = xmlReader->getAttr(0);
699  sfe = new te::da::FunctionEncoder(alias);
700  }
701  else if(encoderType == "BinaryOpEncoder")
702  {
703  std::string alias = xmlReader->getAttr(0);
704  sfe = new te::da::BinaryOpEncoder(alias);
705  }
706  else if(encoderType == "UnaryOpEncoder")
707  {
708  std::string alias = xmlReader->getAttr(0);
709  sfe = new te::da::UnaryOpEncoder(alias);
710  }
711  else if(encoderType == "TemplateEncoder")
712  {
713  std::string alias = xmlReader->getAttr(0);
714  std::string temp = xmlReader->getAttr(1);
715  sfe = new te::da::TemplateEncoder(alias, temp);
716  }
717  else
718  {
719  throw te::da::Exception(TE_TR("Unsupported encoder type!"));
720  }
721 
722  dialect.insert(fname, sfe);
723 
724  xmlReader->next();
725 
726  assert(xmlReader->getNodeType() == te::xml::END_ELEMENT);
727 
728  xmlReader->next();
729  }
730 
731  assert(xmlReader->getNodeType() == te::xml::END_ELEMENT); // SpatialNewGeomOperators
732 
733  //----------------------------
734 
735  xmlReader->next();
736  assert(xmlReader->getNodeType() == te::xml::START_ELEMENT);
737  assert(xmlReader->getElementLocalName() == "SpatialOperators");
738 
739  while(xmlReader->next() &&
740  (xmlReader->getNodeType() == te::xml::START_ELEMENT) &&
741  (xmlReader->getElementLocalName() == "Function"))
742  {
743  te::da::SQLFunctionEncoder* sfe = 0;
744 
745  std::string fname = xmlReader->getAttr("name");
746 
747  qc.addSpatialOperator(fname);
748 
749  xmlReader->next();
750  assert(xmlReader->getNodeType() == te::xml::START_ELEMENT);
751 
752  std::string encoderType = xmlReader->getElementLocalName();
753 
754  if(encoderType == "FunctionEncoder")
755  {
756  std::string alias = xmlReader->getAttr(0);
757  sfe = new te::da::FunctionEncoder(alias);
758  }
759  else if(encoderType == "BinaryOpEncoder")
760  {
761  std::string alias = xmlReader->getAttr(0);
762  sfe = new te::da::BinaryOpEncoder(alias);
763  }
764  else if(encoderType == "UnaryOpEncoder")
765  {
766  std::string alias = xmlReader->getAttr(0);
767  sfe = new te::da::UnaryOpEncoder(alias);
768  }
769  else if(encoderType == "TemplateEncoder")
770  {
771  std::string alias = xmlReader->getAttr(0);
772  std::string temp = xmlReader->getAttr(1);
773  sfe = new te::da::TemplateEncoder(alias, temp);
774  }
775  else
776  {
777  throw te::da::Exception(TE_TR("Unsupported encoder type!"));
778  }
779 
780  dialect.insert(fname, sfe);
781 
782  xmlReader->next();
783 
784  assert(xmlReader->getNodeType() == te::xml::END_ELEMENT);
785 
786  xmlReader->next();
787  }
788 
789  assert(xmlReader->getNodeType() == te::xml::END_ELEMENT); // SpatialOperators
790 
791  xmlReader->next();
792  assert(xmlReader->getNodeType() == te::xml::START_ELEMENT);
793  assert(xmlReader->getElementLocalName() == "LogicalOperators");
794 
795  while(xmlReader->next() &&
796  (xmlReader->getNodeType() == te::xml::START_ELEMENT) &&
797  (xmlReader->getElementLocalName() == "Function"))
798  {
799  te::da::SQLFunctionEncoder* sfe = 0;
800 
801  std::string fname = xmlReader->getAttr("name");
802 
803  qc.addLogicalOperator(fname);
804 
805  xmlReader->next();
806  assert(xmlReader->getNodeType() == te::xml::START_ELEMENT);
807 
808  std::string encoderType = xmlReader->getElementLocalName();
809 
810  if(encoderType == "FunctionEncoder")
811  {
812  std::string alias = xmlReader->getAttr(0);
813  sfe = new te::da::FunctionEncoder(alias);
814  }
815  else if(encoderType == "BinaryOpEncoder")
816  {
817  std::string alias = xmlReader->getAttr(0);
818  sfe = new te::da::BinaryOpEncoder(alias);
819  }
820  else if(encoderType == "UnaryOpEncoder")
821  {
822  std::string alias = xmlReader->getAttr(0);
823  sfe = new te::da::UnaryOpEncoder(alias);
824  }
825  else if(encoderType == "TemplateEncoder")
826  {
827  std::string alias = xmlReader->getAttr(0);
828  std::string temp = xmlReader->getAttr(1);
829  sfe = new te::da::TemplateEncoder(alias, temp);
830  }
831  else
832  {
833  throw te::da::Exception(TE_TR("Unsupported encoder type!"));
834  }
835 
836  dialect.insert(fname, sfe);
837 
838  xmlReader->next();
839 
840  assert(xmlReader->getNodeType() == te::xml::END_ELEMENT);
841 
842  xmlReader->next();
843  }
844 
845  assert(xmlReader->getNodeType() == te::xml::END_ELEMENT); // LogicalOperators
846 
847  xmlReader->next();
848  assert(xmlReader->getNodeType() == te::xml::START_ELEMENT);
849  assert(xmlReader->getElementLocalName() == "ComparsionOperators");
850 
851  while(xmlReader->next() &&
852  (xmlReader->getNodeType() == te::xml::START_ELEMENT) &&
853  (xmlReader->getElementLocalName() == "Function"))
854  {
855  te::da::SQLFunctionEncoder* sfe = 0;
856 
857  std::string fname = xmlReader->getAttr("name");
858 
859  qc.addComparsionOperator(fname);
860 
861  xmlReader->next();
862  assert(xmlReader->getNodeType() == te::xml::START_ELEMENT);
863 
864  std::string encoderType = xmlReader->getElementLocalName();
865 
866  if(encoderType == "FunctionEncoder")
867  {
868  std::string alias = xmlReader->getAttr(0);
869  sfe = new te::da::FunctionEncoder(alias);
870  }
871  else if(encoderType == "BinaryOpEncoder")
872  {
873  std::string alias = xmlReader->getAttr(0);
874  sfe = new te::da::BinaryOpEncoder(alias);
875  }
876  else if(encoderType == "UnaryOpEncoder")
877  {
878  std::string alias = xmlReader->getAttr(0);
879  sfe = new te::da::UnaryOpEncoder(alias);
880  }
881  else if(encoderType == "TemplateEncoder")
882  {
883  std::string alias = xmlReader->getAttr(0);
884  std::string temp = xmlReader->getAttr(1);
885  sfe = new te::da::TemplateEncoder(alias, temp);
886  }
887  else
888  {
889  throw te::da::Exception(TE_TR("Unsupported encoder type!"));
890  }
891 
892  dialect.insert(fname, sfe);
893 
894  xmlReader->next();
895 
896  assert(xmlReader->getNodeType() == te::xml::END_ELEMENT);
897 
898  xmlReader->next();
899  }
900 
901  assert(xmlReader->getNodeType() == te::xml::END_ELEMENT); // ComparsionOperators
902 
903  xmlReader->next();
904  assert(xmlReader->getNodeType() == te::xml::START_ELEMENT);
905  assert(xmlReader->getElementLocalName() == "ArithmeticOperators");
906 
907  while(xmlReader->next() &&
908  (xmlReader->getNodeType() == te::xml::START_ELEMENT) &&
909  (xmlReader->getElementLocalName() == "Function"))
910  {
911  te::da::SQLFunctionEncoder* sfe = 0;
912 
913  std::string fname = xmlReader->getAttr("name");
914 
915  qc.addArithmeticOperator(fname);
916 
917  xmlReader->next();
918  assert(xmlReader->getNodeType() == te::xml::START_ELEMENT);
919 
920  std::string encoderType = xmlReader->getElementLocalName();
921 
922  if(encoderType == "FunctionEncoder")
923  {
924  std::string alias = xmlReader->getAttr(0);
925  sfe = new te::da::FunctionEncoder(alias);
926  }
927  else if(encoderType == "BinaryOpEncoder")
928  {
929  std::string alias = xmlReader->getAttr(0);
930  sfe = new te::da::BinaryOpEncoder(alias);
931  }
932  else if(encoderType == "UnaryOpEncoder")
933  {
934  std::string alias = xmlReader->getAttr(0);
935  sfe = new te::da::UnaryOpEncoder(alias);
936  }
937  else if(encoderType == "TemplateEncoder")
938  {
939  std::string alias = xmlReader->getAttr(0);
940  std::string temp = xmlReader->getAttr(1);
941  sfe = new te::da::TemplateEncoder(alias, temp);
942  }
943  else
944  {
945  throw te::da::Exception(TE_TR("Unsupported encoder type!"));
946  }
947 
948  dialect.insert(fname, sfe);
949 
950  xmlReader->next();
951 
952  assert(xmlReader->getNodeType() == te::xml::END_ELEMENT);
953 
954  xmlReader->next();
955  }
956 
957  assert(xmlReader->getNodeType() == te::xml::END_ELEMENT); // ArithmeticOperators
958 
959  xmlReader->next();
960  assert(xmlReader->getNodeType() == te::xml::START_ELEMENT);
961  assert(xmlReader->getElementLocalName() == "Functions");
962 
963  while(xmlReader->next() &&
964  (xmlReader->getNodeType() == te::xml::START_ELEMENT) &&
965  (xmlReader->getElementLocalName() == "Function"))
966  {
967  te::da::SQLFunctionEncoder* sfe = 0;
968 
969  std::string fname = xmlReader->getAttr("name");
970 
971  qc.addFunction(fname);
972 
973  xmlReader->next();
974  assert(xmlReader->getNodeType() == te::xml::START_ELEMENT);
975 
976  std::string encoderType = xmlReader->getElementLocalName();
977 
978  if(encoderType == "FunctionEncoder")
979  {
980  std::string alias = xmlReader->getAttr(0);
981  sfe = new te::da::FunctionEncoder(alias);
982  }
983  else if(encoderType == "BinaryOpEncoder")
984  {
985  std::string alias = xmlReader->getAttr(0);
986  sfe = new te::da::BinaryOpEncoder(alias);
987  }
988  else if(encoderType == "UnaryOpEncoder")
989  {
990  std::string alias = xmlReader->getAttr(0);
991  sfe = new te::da::UnaryOpEncoder(alias);
992  }
993  else if(encoderType == "TemplateEncoder")
994  {
995  std::string alias = xmlReader->getAttr(0);
996  std::string temp = xmlReader->getAttr(1);
997  sfe = new te::da::TemplateEncoder(alias, temp);
998  }
999  else
1000  {
1001  throw te::da::Exception(TE_TR("Unsupported encoder type!"));
1002  }
1003 
1004  dialect.insert(fname, sfe);
1005 
1006  xmlReader->next();
1007 
1008  assert(xmlReader->getNodeType() == te::xml::END_ELEMENT);
1009 
1010  xmlReader->next();
1011  }
1012 
1013  assert(xmlReader->getNodeType() == te::xml::END_ELEMENT); // Functions
1014 
1015  xmlReader->next();
1016  assert(xmlReader->getNodeType() == te::xml::START_ELEMENT);
1017  assert(xmlReader->getElementLocalName() == "GeomOperands");
1018 
1019  while(xmlReader->next() &&
1020  (xmlReader->getNodeType() == te::xml::START_ELEMENT) &&
1021  (xmlReader->getElementLocalName() == "GeomType"))
1022  {
1023  xmlReader->next();
1024  assert(xmlReader->getNodeType() == te::xml::VALUE);
1025 
1026  std::string geom = boost::to_upper_copy(xmlReader->getElementValue());
1027 
1028  qc.addGeometryOperand(te::gm::Geometry::getGeomTypeId(geom));
1029 
1030  xmlReader->next();
1031 
1032  assert(xmlReader->getNodeType() == te::xml::END_ELEMENT);
1033  }
1034 
1035  assert(xmlReader->getNodeType() == te::xml::END_ELEMENT); // GeomOperands
1036 
1037  xmlReader->next();
1038 
1039  assert(xmlReader->getNodeType() == te::xml::END_ELEMENT); // QueryCapabilities
1040 
1041  capabilities.setQueryCapabilities(qc);
1042 
1043  xmlReader->next();
1044  assert(xmlReader->getNodeType() == te::xml::START_ELEMENT);
1045  assert(xmlReader->getElementLocalName() == "DataSetTypeCapabilities");
1046 
1047  te::da::DataSetTypeCapabilities dstc;
1048 
1049  xmlReader->next();
1050  assert(xmlReader->getNodeType() == te::xml::START_ELEMENT);
1051  assert(xmlReader->getElementLocalName() == "SupportPrimaryKey");
1052 
1053  xmlReader->next();
1054  assert(xmlReader->getNodeType() == te::xml::VALUE);
1055 
1056  dstc.setSupportPrimaryKey(xmlReader->getElementValueAsBoolean());
1057 
1058  xmlReader->next();
1059  assert(xmlReader->getNodeType() == te::xml::END_ELEMENT); // SupportPrimaryKey
1060 
1061  xmlReader->next();
1062  assert(xmlReader->getNodeType() == te::xml::START_ELEMENT);
1063  assert(xmlReader->getElementLocalName() == "SupportUniqueKey");
1064 
1065  xmlReader->next();
1066  assert(xmlReader->getNodeType() == te::xml::VALUE);
1067 
1068  dstc.setSupportUniqueKey(xmlReader->getElementValueAsBoolean());
1069 
1070  xmlReader->next();
1071  assert(xmlReader->getNodeType() == te::xml::END_ELEMENT); // SupportUniqueKey
1072 
1073  xmlReader->next();
1074  assert(xmlReader->getNodeType() == te::xml::START_ELEMENT);
1075  assert(xmlReader->getElementLocalName() == "SupportForeignKey");
1076 
1077  xmlReader->next();
1078  assert(xmlReader->getNodeType() == te::xml::VALUE);
1079 
1080  dstc.setSupportForeingKey(xmlReader->getElementValueAsBoolean());
1081 
1082  xmlReader->next();
1083  assert(xmlReader->getNodeType() == te::xml::END_ELEMENT); // SupportForeignKey
1084 
1085  xmlReader->next();
1086  assert(xmlReader->getNodeType() == te::xml::START_ELEMENT);
1087  assert(xmlReader->getElementLocalName() == "SupportSequence");
1088 
1089  xmlReader->next();
1090  assert(xmlReader->getNodeType() == te::xml::VALUE);
1091 
1092  dstc.setSupportSequence(xmlReader->getElementValueAsBoolean());
1093 
1094  xmlReader->next();
1095  assert(xmlReader->getNodeType() == te::xml::END_ELEMENT); // SupportSequence
1096 
1097  xmlReader->next();
1098  assert(xmlReader->getNodeType() == te::xml::START_ELEMENT);
1099  assert(xmlReader->getElementLocalName() == "SupportCheckConstraints");
1100 
1101  xmlReader->next();
1102  assert(xmlReader->getNodeType() == te::xml::VALUE);
1103 
1104  dstc.setSupportCheckConstraints(xmlReader->getElementValueAsBoolean());
1105 
1106  xmlReader->next();
1107  assert(xmlReader->getNodeType() == te::xml::END_ELEMENT); // SupportCheckConstraints
1108 
1109  xmlReader->next();
1110  assert(xmlReader->getNodeType() == te::xml::START_ELEMENT);
1111  assert(xmlReader->getElementLocalName() == "SupportIndex");
1112 
1113  xmlReader->next();
1114  assert(xmlReader->getNodeType() == te::xml::VALUE);
1115 
1116  dstc.setSupportIndex(xmlReader->getElementValueAsBoolean());
1117 
1118  xmlReader->next();
1119  assert(xmlReader->getNodeType() == te::xml::END_ELEMENT); // SupportIndex
1120 
1121  xmlReader->next();
1122  assert(xmlReader->getNodeType() == te::xml::START_ELEMENT);
1123  assert(xmlReader->getElementLocalName() == "SupportRTreeIndex");
1124 
1125  xmlReader->next();
1126  assert(xmlReader->getNodeType() == te::xml::VALUE);
1127 
1128  dstc.setSupportRTreeIndex(xmlReader->getElementValueAsBoolean());
1129 
1130  xmlReader->next();
1131  assert(xmlReader->getNodeType() == te::xml::END_ELEMENT); // SupportRTreeIndex
1132 
1133  xmlReader->next();
1134  assert(xmlReader->getNodeType() == te::xml::START_ELEMENT);
1135  assert(xmlReader->getElementLocalName() == "SupportBTreeIndex");
1136 
1137  xmlReader->next();
1138  assert(xmlReader->getNodeType() == te::xml::VALUE);
1139 
1140  dstc.setSupportBTreeIndex(xmlReader->getElementValueAsBoolean());
1141 
1142  xmlReader->next();
1143  assert(xmlReader->getNodeType() == te::xml::END_ELEMENT); // SupportBTreeIndex
1144 
1145  xmlReader->next();
1146  assert(xmlReader->getNodeType() == te::xml::START_ELEMENT);
1147  assert(xmlReader->getElementLocalName() == "SupportHashIndex");
1148 
1149  xmlReader->next();
1150  assert(xmlReader->getNodeType() == te::xml::VALUE);
1151 
1152  dstc.setSupportHashIndex(xmlReader->getElementValueAsBoolean());
1153 
1154  xmlReader->next();
1155  assert(xmlReader->getNodeType() == te::xml::END_ELEMENT); // SupportHashIndex
1156 
1157  xmlReader->next();
1158  assert(xmlReader->getNodeType() == te::xml::START_ELEMENT);
1159  assert(xmlReader->getElementLocalName() == "SupportQuadTreeIndex");
1160 
1161  xmlReader->next();
1162  assert(xmlReader->getNodeType() == te::xml::VALUE);
1163 
1164  dstc.setSupportQuadTreeIndex(xmlReader->getElementValueAsBoolean());
1165 
1166  xmlReader->next();
1167  assert(xmlReader->getNodeType() == te::xml::END_ELEMENT); // SupportQuadTreeIndex
1168 
1169  xmlReader->next();
1170  assert(xmlReader->getNodeType() == te::xml::END_ELEMENT); // DataSetTypeCapabilities
1171 
1172  capabilities.setDataSetTypeCapabilities(dstc);
1173 
1174  xmlReader->next();
1175  assert(xmlReader->getNodeType() == te::xml::START_ELEMENT);
1176  assert(xmlReader->getElementLocalName() == "DataSetCapabilities");
1177 
1178  te::da::DataSetCapabilities dsetc;
1179 
1180  xmlReader->next();
1181  assert(xmlReader->getNodeType() == te::xml::START_ELEMENT);
1182  assert(xmlReader->getElementLocalName() == "Bidirectional");
1183 
1184  xmlReader->next();
1185  assert(xmlReader->getNodeType() == te::xml::VALUE);
1186 
1187  dsetc.setSupportBidirectionalTraversing(xmlReader->getElementValueAsBoolean());
1188 
1189  xmlReader->next();
1190  assert(xmlReader->getNodeType() == te::xml::END_ELEMENT); // Bidirectional
1191 
1192  xmlReader->next();
1193  assert(xmlReader->getNodeType() == te::xml::START_ELEMENT);
1194  assert(xmlReader->getElementLocalName() == "Random");
1195 
1196  xmlReader->next();
1197  assert(xmlReader->getNodeType() == te::xml::VALUE);
1198 
1199  dsetc.setSupportRandomTraversing(xmlReader->getElementValueAsBoolean());
1200 
1201  xmlReader->next();
1202  assert(xmlReader->getNodeType() == te::xml::END_ELEMENT); // Random
1203 
1204  xmlReader->next();
1205  assert(xmlReader->getNodeType() == te::xml::START_ELEMENT);
1206  assert(xmlReader->getElementLocalName() == "Indexed");
1207 
1208  xmlReader->next();
1209  assert(xmlReader->getNodeType() == te::xml::VALUE);
1210 
1211  dsetc.setSupportIndexedTraversing(xmlReader->getElementValueAsBoolean());
1212 
1213  xmlReader->next();
1214  assert(xmlReader->getNodeType() == te::xml::END_ELEMENT); // Indexed
1215 
1216  xmlReader->next();
1217  assert(xmlReader->getNodeType() == te::xml::START_ELEMENT);
1218  assert(xmlReader->getElementLocalName() == "EfficientMovePrevious");
1219 
1220  xmlReader->next();
1221  assert(xmlReader->getNodeType() == te::xml::VALUE);
1222 
1223  dsetc.setSupportEfficientMovePrevious(xmlReader->getElementValueAsBoolean());
1224 
1225  xmlReader->next();
1226  assert(xmlReader->getNodeType() == te::xml::END_ELEMENT); // EfficientMovePrevious
1227 
1228  xmlReader->next();
1229  assert(xmlReader->getNodeType() == te::xml::START_ELEMENT);
1230  assert(xmlReader->getElementLocalName() == "EfficientMoveBeforeFirst");
1231 
1232  xmlReader->next();
1233  assert(xmlReader->getNodeType() == te::xml::VALUE);
1234 
1235  dsetc.setSupportEfficientMoveBeforeFirst(xmlReader->getElementValueAsBoolean());
1236 
1237  xmlReader->next();
1238  assert(xmlReader->getNodeType() == te::xml::END_ELEMENT); // EfficientMoveBeforeFirst
1239 
1240  xmlReader->next();
1241  assert(xmlReader->getNodeType() == te::xml::START_ELEMENT);
1242  assert(xmlReader->getElementLocalName() == "EfficientMoveLast");
1243 
1244  xmlReader->next();
1245  assert(xmlReader->getNodeType() == te::xml::VALUE);
1246 
1247  dsetc.setSupportEfficientMoveLast(xmlReader->getElementValueAsBoolean());
1248 
1249  xmlReader->next();
1250  assert(xmlReader->getNodeType() == te::xml::END_ELEMENT); // EfficientMoveLast
1251 
1252  xmlReader->next();
1253  assert(xmlReader->getNodeType() == te::xml::START_ELEMENT);
1254  assert(xmlReader->getElementLocalName() == "EfficientMoveAfterLast");
1255 
1256  xmlReader->next();
1257  assert(xmlReader->getNodeType() == te::xml::VALUE);
1258 
1259  dsetc.setSupportEfficientMoveAfterLast(xmlReader->getElementValueAsBoolean());
1260 
1261  xmlReader->next();
1262  assert(xmlReader->getNodeType() == te::xml::END_ELEMENT); // EfficientMoveAfterLast
1263 
1264  xmlReader->next();
1265  assert(xmlReader->getNodeType() == te::xml::START_ELEMENT);
1266  assert(xmlReader->getElementLocalName() == "EfficientMove");
1267 
1268  xmlReader->next();
1269  assert(xmlReader->getNodeType() == te::xml::VALUE);
1270 
1271  dsetc.setSupportEfficientMove(xmlReader->getElementValueAsBoolean());
1272 
1273  xmlReader->next();
1274  assert(xmlReader->getNodeType() == te::xml::END_ELEMENT); // EfficientMove
1275 
1276  xmlReader->next();
1277  assert(xmlReader->getNodeType() == te::xml::START_ELEMENT);
1278  assert(xmlReader->getElementLocalName() == "EfficientSize");
1279 
1280  xmlReader->next();
1281  assert(xmlReader->getNodeType() == te::xml::VALUE);
1282 
1283  dsetc.setSupportEfficientDataSetSize(xmlReader->getElementValueAsBoolean());
1284 
1285  xmlReader->next();
1286  assert(xmlReader->getNodeType() == te::xml::END_ELEMENT); // EfficientSize
1287 
1288  xmlReader->next();
1289  assert(xmlReader->getNodeType() == te::xml::END_ELEMENT); // DataSetCapabilities
1290 
1291  capabilities.setDataSetCapabilities(dsetc);
1292 
1293  xmlReader->next();
1294  assert(xmlReader->getNodeType() == te::xml::START_ELEMENT);
1295  assert(xmlReader->getElementLocalName() == "SpecificCapabilities");
1296 
1297  while(xmlReader->next() &&
1298  (xmlReader->getNodeType() == te::xml::START_ELEMENT) &&
1299  (xmlReader->getElementLocalName() == "Parameter"))
1300  {
1301  xmlReader->next();
1302  assert(xmlReader->getNodeType() == te::xml::START_ELEMENT);
1303  assert(xmlReader->getElementLocalName() == "Name");
1304 
1305  xmlReader->next();
1306  assert(xmlReader->getNodeType() == te::xml::VALUE);
1307 
1308  std::string paramName = xmlReader->getElementValue();
1309 
1310  xmlReader->next();
1311  assert(xmlReader->getNodeType() == te::xml::END_ELEMENT); // Name
1312 
1313  xmlReader->next();
1314  assert(xmlReader->getNodeType() == te::xml::START_ELEMENT);
1315  assert(xmlReader->getElementLocalName() == "Value");
1316 
1317  xmlReader->next();
1318  assert(xmlReader->getNodeType() == te::xml::VALUE);
1319 
1320  std::string paramValue = xmlReader->getElementValue();
1321 
1322  xmlReader->next();
1323  assert(xmlReader->getNodeType() == te::xml::END_ELEMENT); // Value
1324 
1325  capabilities.addSpecificCapability(paramName, paramValue);
1326 
1327  xmlReader->next();
1328  assert(xmlReader->getNodeType() == te::xml::END_ELEMENT); // Parameter
1329  }
1330 
1331  assert(xmlReader->getNodeType() == te::xml::END_ELEMENT); // SpecificCapabilities
1332 
1333  xmlReader->next();
1334  assert(xmlReader->getNodeType() == te::xml::START_ELEMENT);
1335  assert(xmlReader->getElementLocalName() == "AccessPolicyName");
1336 
1337  xmlReader->next();
1338  assert(xmlReader->getNodeType() == te::xml::VALUE);
1339 
1340  capabilities.setAccessPolicy(Convert2Terralib(xmlReader->getElementValue()));
1341 
1342  xmlReader->next();
1343  assert(xmlReader->getNodeType() == te::xml::END_ELEMENT); // AccessPolicyName
1344 
1345  xmlReader->next();
1346  assert(xmlReader->getNodeType() == te::xml::START_ELEMENT);
1347  assert(xmlReader->getElementLocalName() == "SupportTransactions");
1348 
1349  xmlReader->next();
1350  assert(xmlReader->getNodeType() == te::xml::VALUE);
1351 
1352  capabilities.setSupportTransactions(xmlReader->getElementValueAsBoolean());
1353 
1354  xmlReader->next();
1355  assert(xmlReader->getNodeType() == te::xml::END_ELEMENT); // SupportTransactions
1356 
1357  xmlReader->next();
1358  assert(xmlReader->getNodeType() == te::xml::START_ELEMENT);
1359  assert(xmlReader->getElementLocalName() == "SupportDataSetPesistenceAPI");
1360 
1361  xmlReader->next();
1362  assert(xmlReader->getNodeType() == te::xml::VALUE);
1363 
1364  capabilities.setSupportDataSetPesistenceAPI(xmlReader->getElementValueAsBoolean());
1365 
1366  xmlReader->next();
1367  assert(xmlReader->getNodeType() == te::xml::END_ELEMENT); // SupportDataSetPesistenceAPI
1368 
1369  xmlReader->next();
1370  assert(xmlReader->getNodeType() == te::xml::START_ELEMENT);
1371  assert(xmlReader->getElementLocalName() == "SupportDataSetTypePesistenceAPI");
1372 
1373  xmlReader->next();
1374  assert(xmlReader->getNodeType() == te::xml::VALUE);
1375 
1376  capabilities.setSupportDataSetTypePesistenceAPI(xmlReader->getElementValueAsBoolean());
1377 
1378  xmlReader->next();
1379  assert(xmlReader->getNodeType() == te::xml::END_ELEMENT); // SupportDataSetTypePesistenceAPI
1380 
1381  xmlReader->next();
1382  assert(xmlReader->getNodeType() == te::xml::START_ELEMENT);
1383  assert(xmlReader->getElementLocalName() == "SupportPreparedQueryAPI");
1384 
1385  xmlReader->next();
1386  assert(xmlReader->getNodeType() == te::xml::VALUE);
1387 
1388  capabilities.setSupportPreparedQueryAPI(xmlReader->getElementValueAsBoolean());
1389 
1390  xmlReader->next();
1391  assert(xmlReader->getNodeType() == te::xml::END_ELEMENT); // SupportPreparedQueryAPI
1392 
1393  xmlReader->next();
1394  assert(xmlReader->getNodeType() == te::xml::START_ELEMENT);
1395  assert(xmlReader->getElementLocalName() == "SupportBatchExecutorAPI");
1396 
1397  xmlReader->next();
1398  assert(xmlReader->getNodeType() == te::xml::VALUE);
1399 
1400  capabilities.setSupportBatchExecutorAPI(xmlReader->getElementValueAsBoolean());
1401 
1402  xmlReader->next();
1403  assert(xmlReader->getNodeType() == te::xml::END_ELEMENT); // SupportBatchExecutorAPI
1404 
1405  xmlReader->next();
1406 
1407  assert(xmlReader->getNodeType() == te::xml::END_DOCUMENT); // DataSourceCapabilities
1408 }
1409 
1410 te::da::SQLDialect* te::serialize::xml::ReadDialect(const std::string& dialectFileName)
1411 {
1412  std::auto_ptr<te::xml::Reader> xmlReader(te::xml::ReaderFactory::make());
1413 
1414  xmlReader->read(dialectFileName);
1415 
1416  if(!xmlReader->next())
1417  throw te::da::Exception((boost::format(TE_TR("Could not read query dialect information in file: %1%.")) % dialectFileName).str());
1418 
1419  if(xmlReader->getNodeType() != te::xml::START_ELEMENT)
1420  throw te::da::Exception((boost::format(TE_TR("Error reading the document %1%, the start element wasn't found.")) % dialectFileName).str());
1421 
1422  if(xmlReader->getElementLocalName() != "QueryDialect")
1423  throw te::da::Exception((boost::format(TE_TR("The first tag in the document %1% is not 'QueryDialect'.")) % dialectFileName).str());
1424 
1425  xmlReader->next();
1426  assert(xmlReader->getNodeType() == te::xml::START_ELEMENT);
1427  assert(xmlReader->getElementLocalName() == "DriverName");
1428 
1429  xmlReader->next();
1430  assert(xmlReader->getNodeType() == te::xml::VALUE);
1431  xmlReader->next();
1432  assert(xmlReader->getNodeType() == te::xml::END_ELEMENT);
1433 
1434  xmlReader->next();
1435  assert(xmlReader->getNodeType() == te::xml::START_ELEMENT);
1436  assert(xmlReader->getElementLocalName() == "Functions");
1437 
1438  std::auto_ptr<te::da::SQLDialect> mydialect(new te::da::SQLDialect);
1439 
1440  while(xmlReader->next() &&
1441  (xmlReader->getNodeType() == te::xml::START_ELEMENT) &&
1442  (xmlReader->getElementLocalName() == "Function"))
1443  {
1444  std::string fname = xmlReader->getAttr(0);
1445 
1446  xmlReader->next();
1447  assert(xmlReader->getNodeType() == te::xml::START_ELEMENT);
1448 
1449  std::string encoderType = xmlReader->getElementLocalName();
1450 
1451  te::da::SQLFunctionEncoder* sfe = 0;
1452 
1453  if(encoderType == "FunctionEncoder")
1454  {
1455  std::string alias = xmlReader->getAttr(0);
1456  sfe = new te::da::FunctionEncoder(alias);
1457  }
1458  else if(encoderType == "BinaryOpEncoder")
1459  {
1460  std::string alias = xmlReader->getAttr(0);
1461  sfe = new te::da::BinaryOpEncoder(alias);
1462  }
1463  else if(encoderType == "UnaryOpEncoder")
1464  {
1465  std::string alias = xmlReader->getAttr(0);
1466  sfe = new te::da::UnaryOpEncoder(alias);
1467  }
1468  else
1469  {
1470  throw te::da::Exception(TE_TR("Unsupported encoder type!"));
1471  }
1472 
1473  xmlReader->next();
1474  assert(xmlReader->getNodeType() == te::xml::END_ELEMENT); // End of Encoder
1475 
1476  mydialect->insert(fname, sfe);
1477 
1478  xmlReader->next();
1479  assert(xmlReader->getNodeType() == te::xml::END_ELEMENT); // End of Function
1480  }
1481 
1482  assert(xmlReader->getNodeType() == te::xml::END_DOCUMENT); // End of QueryDialect
1483 
1484  return mydialect.release();
1485 }
1486 
1487 te::da::Distinct* te::serialize::xml::ReadDistinct(te::xml::Reader& reader)
1488 {
1489  assert(reader.getNodeType() == te::xml::START_ELEMENT);
1490  assert(reader.getElementLocalName() == "Distinct");
1491 
1492  reader.next();
1493 
1494  te::da::Distinct* dist = new te::da::Distinct;
1495 
1496  while(reader.getNodeType() == te::xml::START_ELEMENT)
1497  {
1498  te::da::Expression* exp = 0;
1499 
1500  if(reader.getElementLocalName() == "PropertyName")
1501  {
1502  exp = ReadPropertyName(reader);
1503  }
1504  else if(reader.getElementLocalName() == "Literal")
1505  {
1506  exp = ReadLiteral(reader);
1507  }
1508  else if(reader.getElementLocalName() == "Function")
1509  {
1510  exp = ReadFunction(reader);
1511  }
1512 
1513  dist->push_back(exp);
1514  }
1515 
1516  assert(reader.getNodeType() == te::xml::END_ELEMENT); // Distinct
1517 
1518  reader.next();
1519 
1520  return dist;
1521 }
1522 
1523 te::da::Fields* te::serialize::xml::ReadFields(te::xml::Reader& reader)
1524 {
1525  assert(reader.getNodeType() == te::xml::START_ELEMENT);
1526  assert(reader.getElementLocalName() == "Fields");
1527 
1528  reader.next();
1529 
1530  te::da::Fields* fields = new te::da::Fields;
1531 
1532  while(reader.getNodeType() == te::xml::START_ELEMENT)
1533  {
1534  te::da::Field* f = 0;
1535  assert(reader.getElementLocalName() == "Field");
1536  reader.next();
1537  assert(reader.getNodeType() == te::xml::START_ELEMENT);
1538 
1539  if(reader.getElementLocalName() == "PropertyName")
1540  {
1541  f = new te::da::Field(ReadPropertyName(reader));
1542  fields->push_back(f);
1543  }
1544 
1545  else if(reader.getElementLocalName() == "Function")
1546  {
1547  f = new te::da::Field(ReadFunction(reader));
1548  fields->push_back(f);
1549  }
1550  else if(reader.getElementLocalName() == "Literal")
1551  {
1552  f = new te::da::Field(ReadLiteral(reader));
1553  fields->push_back(f);
1554  }
1555  if (f != 0)
1556  {
1557  if (reader.getNodeType() == te::xml::START_ELEMENT)
1558  {
1559  if (reader.getElementLocalName() == "Alias")
1560  {
1561  reader.next();
1562  assert(reader.getNodeType() == te::xml::VALUE);
1563  f->setAlias(new std::string(reader.getElementValue()));
1564  reader.next();
1565  assert(reader.getNodeType() == te::xml::END_ELEMENT); // Alias
1566  reader.next();
1567  }
1568  }
1569  }
1570 
1571  assert(reader.getNodeType() == te::xml::END_ELEMENT); // Field
1572 
1573  reader.next();
1574  }
1575 
1576  assert(reader.getNodeType() == te::xml::END_ELEMENT); // Fields
1577 
1578  reader.next();
1579 
1580  return fields;
1581 }
1582 
1583 te::da::From* te::serialize::xml::ReadFrom(te::xml::Reader& reader)
1584 {
1585  assert(reader.getNodeType() == te::xml::START_ELEMENT);
1586  assert(reader.getElementLocalName() == "From");
1587 
1588  reader.next();
1589 
1590  te::da::From* from = new te::da::From;
1591 
1592  while(reader.getNodeType() == te::xml::START_ELEMENT)
1593  {
1594  if(reader.getElementLocalName() == "FromItem")
1595  {
1596  from->push_back(ReadFromItem(reader));
1597  }
1598  else if(reader.getElementLocalName() == "JoinItem")
1599  {
1600  reader.next();
1601 
1602  te::da::FromItem* first = ReadFromItem(reader);
1603  te::da::FromItem* second = ReadFromItem(reader);
1604 
1605  assert(reader.getNodeType() == te::xml::START_ELEMENT);
1606  assert(reader.getElementLocalName() == "Type");
1607 
1608  reader.next();
1609 
1610  assert(reader.getNodeType() == te::xml::VALUE);
1611 
1612  std::string type = reader.getElementValue();
1613 
1614  reader.next();
1615 
1616  te::da::JoinType joinType = te::da::JOIN;
1617 
1618  if(type == "JOIN")
1619  joinType = te::da::JOIN;
1620  else if (type == "INNER_JOIN")
1621  joinType = te::da::INNER_JOIN;
1622  else if (type == "LEFT_JOIN")
1623  joinType = te::da::LEFT_JOIN;
1624  else if (type == "RIGHT_JOIN")
1625  joinType = te::da::RIGHT_JOIN;
1626  else if (type == "FULL_OUTER_JOIN")
1627  joinType = te::da::FULL_OUTER_JOIN;
1628  else if ( type == "CROSS_JOIN")
1629  joinType = te::da::CROSS_JOIN;
1630  else
1631  joinType = te::da::NATURAL_JOIN;
1632 
1633  assert(reader.getNodeType() == te::xml::END_ELEMENT); // Type
1634 
1635  reader.next();
1636 
1637  assert(reader.getNodeType() == te::xml::START_ELEMENT);
1638  assert(reader.getElementLocalName() == "Condition");
1639 
1640  reader.next();
1641  te::da::JoinCondition* JoinCondition = 0;
1642  assert(reader.getNodeType() == te::xml::START_ELEMENT);
1643 
1644  if(reader.getElementLocalName() == "JoinConditionOn")
1645  {
1646  reader.next();
1647  JoinCondition = new te::da::JoinConditionOn(ReadFunction(reader));
1648  assert(reader.getNodeType() == te::xml::END_ELEMENT); // JoinConditionOn
1649  }
1650  else if(reader.getElementLocalName() == "JoinConditionUsing")
1651  {
1652  reader.next();
1653  while(reader.getNodeType() == te::xml::START_ELEMENT && reader.getElementLocalName() == "PropertyName")
1654  {
1655  JoinCondition = new te::da::JoinConditionUsing();
1656  dynamic_cast<te::da::JoinConditionUsing*>(JoinCondition)->push_back(ReadPropertyName(reader));
1657  }
1658  assert(reader.getNodeType() == te::xml::END_ELEMENT); // JoinConditionUsing
1659  }
1660 
1661  reader.next();
1662  assert(reader.getNodeType() == te::xml::END_ELEMENT); // Condition
1663 
1664  te::da::Join* join = new te::da::Join(first, second, joinType, JoinCondition);
1665  from->push_back(join);
1666 
1667  reader.next();
1668  assert(reader.getNodeType() == te::xml::END_ELEMENT); // JoinItem
1669  reader.next();
1670  }
1671  }
1672 
1673  assert(reader.getNodeType() == te::xml::END_ELEMENT); // From
1674  reader.next();
1675 
1676  return from;
1677 }
1678 
1679 te::da::FromItem* te::serialize::xml::ReadFromItem(te::xml::Reader& reader)
1680 {
1681  assert(reader.getNodeType() == te::xml::START_ELEMENT);
1682  assert(reader.getElementLocalName() == "FromItem");
1683 
1684  reader.next();
1685 
1686  assert(reader.getNodeType() == te::xml::START_ELEMENT);
1687  assert(reader.getElementLocalName() == "Value");
1688 
1689  reader.next();
1690 
1691  assert(reader.getNodeType() == te::xml::VALUE);
1692 
1693  std::string name = reader.getElementValue();
1694 
1695  reader.next();
1696 
1697  assert(reader.getNodeType() == te::xml::END_ELEMENT);
1698 
1699  reader.next();
1700 
1701  assert(reader.getNodeType() == te::xml::START_ELEMENT);
1702  assert(reader.getElementLocalName() == "Alias");
1703 
1704  reader.next();
1705 
1706  assert(reader.getNodeType() == te::xml::VALUE);
1707 
1708  std::string alias = reader.getElementValue();
1709 
1710  reader.next();
1711 
1712  assert(reader.getNodeType() == te::xml::END_ELEMENT);
1713 
1714  reader.next();
1715 
1716  assert(reader.getNodeType() == te::xml::END_ELEMENT); // FromItem
1717 
1718  reader.next();
1719 
1720  return new te::da::DataSetName(name, alias);
1721 }
1722 
1723 te::da::Function* te::serialize::xml::ReadFunction(te::xml::Reader& reader)
1724 {
1725  assert(reader.getNodeType() == te::xml::START_ELEMENT);
1726  assert(reader.getElementLocalName() == "Function");
1727 
1728  reader.next();
1729 
1730  assert(reader.getNodeType() == te::xml::START_ELEMENT);
1731  assert(reader.getElementLocalName() == "Name");
1732 
1733  reader.next();
1734 
1735  assert(reader.getNodeType() == te::xml::VALUE);
1736 
1737  std::string name = reader.getElementValue();
1738 
1739  reader.next();
1740 
1741  assert(reader.getNodeType() == te::xml::END_ELEMENT);
1742 
1743  reader.next();
1744 
1745  te::da::Expression* exp1 = 0;
1746  te::da::Expression* exp2 = 0;
1747 
1748  std::size_t countAux = 0;
1749  assert(reader.getNodeType() == te::xml::START_ELEMENT);
1750  while(reader.getNodeType() == te::xml::START_ELEMENT)
1751  {
1752  te::da::Expression* exp = 0;
1753 
1754  if(reader.getElementLocalName() == "PropertyName")
1755  {
1756  exp = ReadPropertyName(reader);
1757  }
1758  else if(reader.getElementLocalName() == "Literal")
1759  {
1760  exp = ReadLiteral(reader);
1761  }
1762  else if(reader.getElementLocalName() == "Function")
1763  {
1764  exp = ReadFunction(reader);
1765  }
1766 
1767  if(countAux == 0)
1768  exp1 = exp;
1769  else
1770  exp2 = exp;
1771 
1772  ++countAux;
1773  }
1774 
1775  assert(reader.getNodeType() == te::xml::END_ELEMENT); // Function
1776 
1777  te::da::BinaryFunction* func = new te::da::BinaryFunction(name, exp1, exp2);
1778 
1779  reader.next();
1780 
1781  return func;
1782 }
1783 
1784 te::da::GroupBy* te::serialize::xml::ReadGroupBy(te::xml::Reader& reader)
1785 {
1786  assert(reader.getNodeType() == te::xml::START_ELEMENT);
1787  assert(reader.getElementLocalName() == "GroupBy");
1788 
1789  reader.next();
1790 
1791  te::da::GroupBy* groupBy = new te::da::GroupBy;
1792 
1793  while(reader.getNodeType() == te::xml::START_ELEMENT)
1794  {
1795  assert(reader.getElementLocalName() == "GroupByItem");
1796 
1797  reader.next();
1798 
1799  te::da::Expression* exp = 0;
1800 
1801  if(reader.getElementLocalName() == "PropertyName")
1802  {
1803  exp = ReadPropertyName(reader);
1804  }
1805  else if(reader.getElementLocalName() == "Literal")
1806  {
1807  exp = ReadLiteral(reader);
1808  }
1809  else if(reader.getElementLocalName() == "Function")
1810  {
1811  exp = ReadFunction(reader);
1812  }
1813 
1814  te::da::GroupByItem* groupByItem = new te::da::GroupByItem(exp);
1815 
1816  groupBy->push_back(groupByItem);
1817 
1818  assert(reader.getNodeType() == te::xml::END_ELEMENT); //GroupByItem
1819 
1820  reader.next();
1821  }
1822 
1823  assert(reader.getNodeType() == te::xml::END_ELEMENT); // GroupBy
1824 
1825  reader.next();
1826 
1827  return groupBy;
1828 }
1829 
1830 te::da::Having* te::serialize::xml::ReadHaving(te::xml::Reader& reader)
1831 {
1832  assert(reader.getNodeType() == te::xml::START_ELEMENT);
1833  assert(reader.getElementLocalName() == "Having");
1834 
1835  reader.next();
1836 
1837  te::da::Expression* exp = 0;
1838 
1839  if(reader.getElementLocalName() == "PropertyName")
1840  {
1841  exp = ReadPropertyName(reader);
1842  }
1843  else if(reader.getElementLocalName() == "Literal")
1844  {
1845  exp = ReadLiteral(reader);
1846  }
1847  else if(reader.getElementLocalName() == "Function")
1848  {
1849  exp = ReadFunction(reader);
1850  }
1851 
1852  assert(reader.getNodeType() == te::xml::END_ELEMENT); //Having
1853 
1854  reader.next();
1855 
1856  return new te::da::Having(exp);
1857 }
1858 
1859 te::da::Literal* te::serialize::xml::ReadLiteral(te::xml::Reader& reader)
1860 {
1861  assert(reader.getNodeType() == te::xml::START_ELEMENT);
1862  assert(reader.getElementLocalName() == "Literal");
1863 
1864  std::size_t litType = reader.getAttrAsInt32("type");
1865 
1866  reader.next();
1867 
1868  assert(reader.getNodeType() == te::xml::VALUE);
1869 
1870  std::string value = reader.getElementValue();
1871 
1872  reader.next();
1873 
1874  assert(reader.getNodeType() == te::xml::END_ELEMENT); // Literal
1875 
1876  reader.next();
1877 
1878  te::da::Literal* lit = 0;
1879 
1880  // TODO: Others data type
1881  switch(litType)
1882  {
1883  case te::dt::STRING_TYPE:
1884  {
1885  lit = new te::da::LiteralString(value);
1886  break;
1887  }
1888  case te::dt::INT16_TYPE:
1889  {
1890  lit = new te::da::LiteralInt16(boost::lexical_cast<int16_t>(value));
1891  break;
1892  }
1893  case te::dt::INT32_TYPE:
1894  {
1895  lit = new te::da::LiteralInt32(boost::lexical_cast<int32_t>(value));
1896  break;
1897  }
1898  case te::dt::INT64_TYPE:
1899  {
1900  lit = new te::da::LiteralInt64(boost::lexical_cast<int64_t>(value));
1901  break;
1902  }
1903  case te::dt::DOUBLE_TYPE:
1904  {
1905  lit = new te::da::LiteralDouble(boost::lexical_cast<double>(value));
1906  break;
1907  }
1908  case te::dt::GEOMETRY_TYPE:
1909  {
1910  std::auto_ptr<te::gm::Geometry> geom(te::gm::WKTReader::read(value.c_str()));
1911 
1912  lit = new te::da::LiteralGeom(geom.release());
1913  break;
1914  }
1915  default:
1916  throw te::da::Exception(TE_TR("Data Type Undefined!"));
1917 
1918  }
1919 
1920  return lit;
1921 }
1922 
1923 te::da::OrderBy* te::serialize::xml::ReadOrderBy(te::xml::Reader& reader)
1924 {
1925  assert(reader.getNodeType() == te::xml::START_ELEMENT);
1926  assert(reader.getElementLocalName() == "OrderBy");
1927 
1928  reader.next();
1929 
1930  te::da::OrderBy* orderBy = new te::da::OrderBy;
1931 
1932  while(reader.getNodeType() == te::xml::START_ELEMENT)
1933  {
1934  assert(reader.getElementLocalName() == "OrderByItem");
1935 
1936  reader.next();
1937 
1938  te::da::Expression* exp = 0;
1939 
1940  if(reader.getElementLocalName() == "PropertyName")
1941  {
1942  exp = ReadPropertyName(reader);
1943  }
1944  else if(reader.getElementLocalName() == "Literal")
1945  {
1946  exp = ReadLiteral(reader);
1947  }
1948  else if(reader.getElementLocalName() == "Function")
1949  {
1950  exp = ReadFunction(reader);
1951  }
1952 
1953  assert(reader.getNodeType() == te::xml::START_ELEMENT);
1954 
1955  assert(reader.getElementLocalName() == "SortOrder");
1956 
1957  reader.next();
1958 
1959  assert(reader.getNodeType() == te::xml::VALUE);
1960 
1961  std::string sortOrder = reader.getElementValue();
1962 
1963  te::da::SortOrder order = sortOrder == "ASC" ? te::da::ASC : te::da::DESC;
1964 
1965  te::da::OrderByItem* orderByItem = new te::da::OrderByItem(exp, order);
1966 
1967  orderBy->push_back(orderByItem);
1968 
1969  reader.next();
1970 
1971  assert(reader.getNodeType() == te::xml::END_ELEMENT);
1972 
1973  reader.next();
1974 
1975  assert(reader.getNodeType() == te::xml::END_ELEMENT); //OrderByItem
1976 
1977  reader.next();
1978  }
1979 
1980  assert(reader.getNodeType() == te::xml::END_ELEMENT); // OrderBy
1981 
1982  reader.next();
1983 
1984  return orderBy;
1985 }
1986 
1987 te::da::PropertyName* te::serialize::xml::ReadPropertyName(te::xml::Reader& reader)
1988 {
1989  assert(reader.getNodeType() == te::xml::START_ELEMENT);
1990  assert(reader.getElementLocalName() == "PropertyName");
1991 
1992  reader.next();
1993 
1994  assert(reader.getNodeType() == te::xml::VALUE);
1995 
1996  std::string name = reader.getElementValue();
1997 
1998  reader.next();
1999 
2000  assert(reader.getNodeType() == te::xml::END_ELEMENT); // PropertyName
2001 
2002  reader.next();
2003 
2004  return new te::da::PropertyName(name);
2005 }
2006 
2007 te::da::Select* te::serialize::xml::ReadSelect(te::xml::Reader& reader)
2008 {
2009  assert(reader.getNodeType() == te::xml::START_ELEMENT);
2010  assert(reader.getElementLocalName() == "Select");
2011 
2012  te::da::Select* select = new te::da::Select();
2013 
2014  reader.next();
2015 
2016  if(reader.getElementLocalName() == "Fields" && reader.getNodeType() == te::xml::START_ELEMENT)
2017  {
2018  te::da::Fields* fields = ReadFields(reader);
2019  select->setFields(fields);
2020  }
2021 
2022  if(reader.getElementLocalName() == "From" && reader.getNodeType() == te::xml::START_ELEMENT)
2023  {
2024  te::da::From* from = ReadFrom(reader);
2025  select->setFrom(from);
2026  }
2027 
2028  if(reader.getElementLocalName() == "Where" && reader.getNodeType() == te::xml::START_ELEMENT)
2029  {
2030  te::da::Where* wh = ReadWhere(reader);
2031  select->setWhere(wh);
2032  }
2033 
2034  if(reader.getElementLocalName() == "GroupBy" && reader.getNodeType() == te::xml::START_ELEMENT)
2035  {
2036  te::da::GroupBy* gBy = ReadGroupBy(reader);
2037  select->setGroupBy(gBy);
2038  }
2039 
2040  if(reader.getElementLocalName() == "Having" && reader.getNodeType() == te::xml::START_ELEMENT)
2041  {
2042  te::da::Having* having = ReadHaving(reader);
2043  select->setHaving(having);
2044  }
2045 
2046  if(reader.getElementLocalName() == "OrderBy" && reader.getNodeType() == te::xml::START_ELEMENT)
2047  {
2048  te::da::OrderBy* oBy = ReadOrderBy(reader);
2049  select->setOrderBy(oBy);
2050  }
2051 
2052  if(reader.getElementLocalName() == "Distinct" && reader.getNodeType() == te::xml::START_ELEMENT)
2053  {
2054  te::da::Distinct* distinct = ReadDistinct(reader);
2055  select->setDistinct(distinct);
2056  }
2057 
2058  if(reader.getElementLocalName() == "Limit" && reader.getNodeType() == te::xml::START_ELEMENT)
2059  {
2060  reader.next();
2061  assert(reader.getNodeType() == te::xml::VALUE);
2062  select->setLimit(boost::lexical_cast<std::size_t>(reader.getElementValue()));
2063  reader.next();
2064  assert(reader.getNodeType() == te::xml::END_ELEMENT); // Limit
2065  reader.next();
2066  }
2067 
2068  if(reader.getElementLocalName() == "Offset" && reader.getNodeType() == te::xml::START_ELEMENT)
2069  {
2070  reader.next();
2071  assert(reader.getNodeType() == te::xml::VALUE);
2072  select->setOffset(boost::lexical_cast<std::size_t>(reader.getElementValue()));
2073  reader.next();
2074  assert(reader.getNodeType() == te::xml::END_ELEMENT); // Offset
2075  reader.next();
2076  }
2077 
2078  assert(reader.getNodeType() == te::xml::END_ELEMENT); // Select
2079 
2080  reader.next();
2081 
2082  return select;
2083 }
2084 
2085 te::da::Where* te::serialize::xml::ReadWhere(te::xml::Reader& reader)
2086 {
2087  assert(reader.getNodeType() == te::xml::START_ELEMENT);
2088  assert(reader.getElementLocalName() == "Where");
2089 
2090  reader.next();
2091 
2092  te::da::Where* wh = 0;
2093 
2094  assert(reader.getNodeType() == te::xml::START_ELEMENT);
2095  if(reader.getElementLocalName() == "PropertyName")
2096  {
2097  wh = new te::da::Where(ReadPropertyName(reader));
2098  }
2099  else if(reader.getElementLocalName() == "Function")
2100  {
2101  wh = new te::da::Where(ReadFunction(reader));
2102  }
2103  else if(reader.getElementLocalName() == "Literal")
2104  {
2105  wh = new te::da::Where(ReadLiteral(reader));
2106  }
2107 
2108  assert(reader.getNodeType() == te::xml::END_ELEMENT); // Where
2109 
2110  reader.next();
2111 
2112  return wh;
2113 }
2114 
2115 void te::serialize::xml::Save(const te::da::Distinct* distinct, te::xml::AbstractWriter& writer)
2116 {
2117  assert(distinct);
2118  writer.writeStartElement("te_da:Distinct");
2119 
2120  for(std::size_t i = 0; i < distinct->size(); ++i)
2121  {
2122  const te::da::Expression& exp = distinct->at(i);
2123 
2124  Save(&exp, writer);
2125  }
2126 
2127  writer.writeEndElement("te_da:Distinct");
2128 }
2129 
2130 void te::serialize::xml::Save(const te::da::Expression* expression, te::xml::AbstractWriter& writer)
2131 {
2132  assert(expression);
2133 
2134  std::auto_ptr<te::da::Expression> exp(expression->clone());
2135 
2136  // Check Expression Type
2137  te::da::PropertyName* pName = dynamic_cast<te::da::PropertyName*>(exp.get());
2138  te::da::Function* func = dynamic_cast<te::da::Function*>(exp.get());
2139  te::da::Literal* lit = dynamic_cast<te::da::Literal*>(exp.get());
2140 
2141  if(pName)
2142  Save(pName, writer);
2143  else if(func)
2144  Save(func, writer);
2145  else if(lit)
2146  Save(lit, writer);
2147  else
2148  throw te::da::Exception(TE_TR("Error: Expression Type Undefined!"));
2149 }
2150 
2151 void te::serialize::xml::Save(const te::da::Field* field, te::xml::AbstractWriter& writer)
2152 {
2153  assert(field);
2154  writer.writeStartElement("te_da:Field");
2155 
2156  Save(field->getExpression(), writer);
2157 
2158  if(field->getAlias())
2159  {
2160  writer.writeStartElement("te_da:Alias");
2161 
2162  writer.writeValue(*field->getAlias());
2163 
2164  writer.writeEndElement("te_da:Alias");
2165  }
2166 
2167  writer.writeEndElement("te_da:Field");
2168 
2169 }
2170 
2171 void te::serialize::xml::Save(const te::da::Fields* fields, te::xml::AbstractWriter& writer)
2172 {
2173  assert(fields);
2174  writer.writeStartElement("te_da:Fields");
2175 
2176  for(std::size_t i = 0; i < fields->size(); ++i)
2177  {
2178  const te::da::Field& item = fields->at(i);
2179 
2180  Save(&item, writer);
2181  }
2182 
2183  writer.writeEndElement("te_da:Fields");
2184 }
2185 
2186 void te::serialize::xml::Save(const te::da::From* from, te::xml::AbstractWriter& writer)
2187 {
2188  writer.writeStartElement("te_da:From");
2189 
2190  for(std::size_t i = 0; i < from->size(); ++i)
2191  {
2192  const te::da::FromItem& item= from->at(i);
2193 
2194  Save(&item, writer);
2195  }
2196 
2197  writer.writeEndElement("te_da:From");
2198 }
2199 
2200 void te::serialize::xml::Save(const te::da::FromItem* fromItem, te::xml::AbstractWriter& writer)
2201 {
2202  const te::da::DataSetName* dsName = dynamic_cast<const te::da::DataSetName*>(fromItem);
2203  if(dsName)
2204  {
2205  writer.writeStartElement("te_da:FromItem");
2206 
2207  writer.writeStartElement("te_da:Value");
2208 
2209  writer.writeValue(dsName->getName());
2210 
2211  writer.writeEndElement("te_da:Value");
2212 
2213  writer.writeStartElement("te_da:Alias");
2214 
2215  writer.writeValue(fromItem->getAlias());
2216 
2217  writer.writeEndElement("te_da:Alias");
2218 
2219  writer.writeEndElement("te_da:FromItem");
2220  }
2221 
2222  const te::da::Join* dsJoin = dynamic_cast<const te::da::Join*>(fromItem);
2223  if(dsJoin)
2224  {
2225  writer.writeStartElement("te_da:JoinItem");
2226 
2227  Save(dsJoin->getFirst(), writer);
2228 
2229  Save(dsJoin->getSecond(), writer);
2230 
2231  std::string joinType;
2232  switch(dsJoin->getType())
2233  {
2234  case te::da::JOIN:
2235  joinType = "JOIN";
2236  break;
2237  case te::da::INNER_JOIN:
2238  joinType = "INNER_JOIN";
2239  break;
2240  case te::da::LEFT_JOIN:
2241  joinType = "LEFT_JOIN";
2242  break;
2243  case te::da::RIGHT_JOIN:
2244  joinType = "RIGHT_JOIN";
2245  break;
2246  case te::da::FULL_OUTER_JOIN:
2247  joinType = "FULL_OUTER_JOIN";
2248  break;
2249  case te::da::CROSS_JOIN:
2250  joinType = "CROSS_JOIN";
2251  break;
2252  case te::da::NATURAL_JOIN:
2253  joinType = "NATURAL_JOIN";
2254  break;
2255  default:
2256  joinType = "JOIN";
2257  }
2258 
2259  writer.writeElement("te_da:Type",joinType);
2260 
2261  writer.writeStartElement("te_da:Condition");
2262 
2263  const te::da::JoinConditionOn* joinOn = dynamic_cast<const te::da::JoinConditionOn*>(dsJoin->getCondition());
2264  if(joinOn)
2265  {
2266  writer.writeStartElement("te_da:JoinConditionOn");
2267  te::da::Expression* exp = joinOn->getCondition();
2268  Save(exp, writer);
2269  writer.writeEndElement("te_da:JoinConditionOn");
2270  }
2271  const te::da::JoinConditionUsing* joinUsing = dynamic_cast<const te::da::JoinConditionUsing*>(dsJoin->getCondition());
2272  if(joinUsing)
2273  {
2274  writer.writeStartElement("te_da:JoinConditionUsing");
2275  for(std::size_t i = 0; i < joinUsing->getNumFields(); ++i)
2276  {
2277  const te::da::Expression* exp = (*joinUsing)[i];
2278  Save(exp, writer);
2279  }
2280  writer.writeEndElement("te_da:JoinConditionUsing");
2281  }
2282 
2283  writer.writeEndElement("te_da:Condition");
2284 
2285  writer.writeEndElement("te_da:JoinItem");
2286  }
2287 }
2288 
2289 void te::serialize::xml::Save(const te::da::Function* func, te::xml::AbstractWriter& writer)
2290 {
2291  assert(func);
2292  writer.writeStartElement("te_da:Function");
2293 
2294  std::string funcName = func->getName();
2295 
2296  writer.writeElement("te_da:Name", funcName);
2297 
2298  for(std::size_t i = 0; i < func->getNumArgs(); i++)
2299  {
2300  Save(func->getArg(i), writer);
2301  }
2302 
2303  writer.writeEndElement("te_da:Function");
2304 }
2305 
2306 void te::serialize::xml::Save(const te::da::GroupByItem* groupByItem, te::xml::AbstractWriter& writer)
2307 {
2308  assert(groupByItem);
2309  writer.writeStartElement("te_da:GroupByItem");
2310 
2311  Save(groupByItem->getExpression(), writer);
2312 
2313  writer.writeEndElement("te_da:GroupByItem");
2314 }
2315 
2316 void te::serialize::xml::Save(const te::da::GroupBy* groupBy, te::xml::AbstractWriter& writer)
2317 {
2318  writer.writeStartElement("te_da:GroupBy");
2319 
2320  for(std::size_t i = 0; i < groupBy->size(); ++i)
2321  {
2322  const te::da::GroupByItem& item = groupBy->at(i);
2323 
2324  Save(&item, writer);
2325  }
2326 
2327  writer.writeEndElement("te_da:GroupBy");
2328 }
2329 
2330 void te::serialize::xml::Save(const te::da::Having* having, te::xml::AbstractWriter& writer)
2331 {
2332  assert(having);
2333  writer.writeStartElement("te_da:Having");
2334 
2335  Save(having->getExp(), writer);
2336 
2337  writer.writeEndElement("te_da:Having");
2338 }
2339 
2340 void te::serialize::xml::Save(const te::da::Literal* lit, te::xml::AbstractWriter& writer)
2341 {
2342  assert(lit);
2343  writer.writeStartElement("te_da:Literal");
2344 
2345  te::dt::AbstractData* d = lit->getValue();
2346 
2347  writer.writeAttribute("type", d->getTypeCode());
2348 
2349  writer.writeValue(d->toString());
2350 
2351  writer.writeEndElement("te_da:Literal");
2352 }
2353 
2354 void te::serialize::xml::Save(const te::da::OrderByItem* orderByItem, te::xml::AbstractWriter& writer)
2355 {
2356  assert(orderByItem);
2357  writer.writeStartElement("te_da:OrderByItem");
2358 
2359  Save(orderByItem->getExpression(), writer);
2360 
2361  writer.writeStartElement("te_da:SortOrder");
2362  std::string so = (orderByItem->getSortOrder() == te::da::ASC ? "ASC" : "DESC");
2363  writer.writeValue(so);
2364  writer.writeEndElement("te_da:SortOrder");
2365 
2366  writer.writeEndElement("te_da:OrderByItem");
2367 }
2368 
2369 void te::serialize::xml::Save(const te::da::OrderBy* orderBy, te::xml::AbstractWriter& writer)
2370 {
2371  writer.writeStartElement("te_da:OrderBy");
2372 
2373  for(std::size_t i = 0; i < orderBy->size(); ++i)
2374  {
2375  const te::da::OrderByItem& item = orderBy->at(i);
2376 
2377  Save(&item, writer);
2378  }
2379 
2380  writer.writeEndElement("te_da:OrderBy");
2381 }
2382 
2383 void te::serialize::xml::Save(const te::da::PropertyName* propertyName, te::xml::AbstractWriter& writer)
2384 {
2385  assert(propertyName);
2386 
2387  writer.writeElement("te_da:PropertyName", propertyName->getName());
2388 }
2389 
2390 void te::serialize::xml::Save(const te::da::Select* select, te::xml::AbstractWriter& writer)
2391 {
2392  assert(select);
2393  writer.writeStartElement("te_da:Select");
2394 
2395  const te::da::Fields* fields = select->getFields();
2396  if(fields)
2397  Save(fields, writer); // Fields
2398 
2399  const te::da::From* from = select->getFrom();
2400  if(from)
2401  Save(from, writer); // From
2402 
2403  const te::da::Where* wh = select->getWhere();
2404  if(wh)
2405  Save(wh, writer); // Where
2406 
2407  const te::da::GroupBy* groupBy = select->getGroupBy();
2408  if(groupBy)
2409  Save(groupBy, writer); // GroupBy
2410 
2411  const te::da::Having* having = select->getHaving();
2412  if(having)
2413  Save(having, writer); // Having
2414 
2415  const te::da::OrderBy* orderBy = select->getOrderBy();
2416  if(orderBy)
2417  Save(orderBy, writer); // OrderBy
2418 
2419  const te::da::Distinct* distinct = select->getDistinct();
2420  if(distinct)
2421  Save(distinct, writer); // Distinct
2422 
2423  if(select->getLimit() != 0) // Limit
2424  {
2425  writer.writeStartElement("te_da:Limit");
2426  writer.writeValue(static_cast<unsigned int>(select->getLimit()));
2427  writer.writeEndElement("te_da:Limit");
2428  }
2429 
2430  if(select->getOffset() != 0) // Offset
2431  {
2432  writer.writeStartElement("te_da:Offset");
2433  writer.writeValue(static_cast<unsigned int>(select->getOffset()));
2434  writer.writeEndElement("te_da:Offset");
2435  }
2436 
2437  writer.writeEndElement("te_da:Select");
2438 }
2439 
2440 void te::serialize::xml::Save(const te::da::Where* wh, te::xml::AbstractWriter& writer)
2441 {
2442  writer.writeStartElement("te_da:Where");
2443 
2444  Save(wh->getExp(), writer);
2445 
2446  writer.writeEndElement("te_da:Where");
2447 }
te::da::Having
A class that can be used to model a filter expression that can be applied to a query.
Definition: Having.h:47
te::da::Function::getArg
Expression * getArg(std::size_t i) const
It returns the i-th function argument.
Definition: Function.cpp:67
te::common::ConvertLatin1UTFString
TECOMMONEXPORT std::string ConvertLatin1UTFString(const std::string &data, const bool &toUtf=true)
Converts a string from latin1 to utf8 and vice-versa.
Definition: BoostUtils.cpp:169
te::da::Select::getDistinct
const Distinct * getDistinct() const
It returns the Distinct modifier.
Definition: Select.cpp:992
te::dt::CompositeProperty::getProperty
Property * getProperty(std::size_t i) const
It returns the i-th property.
Definition: CompositeProperty.h:171
te::da::DataSourceInfoManager::iterator
std::map< std::string, DataSourceInfoPtr >::iterator iterator
Definition: DataSourceInfoManager.h:56
te::da::PropertyName::getName
const std::string & getName() const
It returns the property name.
Definition: PropertyName.h:80
te::da::GroupBy
boost::ptr_vector< GroupByItem > GroupBy
A class that can be used to model a GROUP BY clause.
Definition: GroupBy.h:37
dialect
te::da::SQLDialect * dialect
Definition: WFSDialect.h:1
te::da::DataSetTypeCapabilities
A class that informs what kind of constraint and index is supported by a given data source...
Definition: DataSetTypeCapabilities.h:43
te::da::Select::getOrderBy
const OrderBy * getOrderBy() const
It returns the list of expressions used to sort the output result.
Definition: Select.cpp:982
te::da::GroupByItem
A class that can be used in a GROUP BY clause.
Definition: GroupByItem.h:50
te::da::FromItem
An abstract class that models a source of data in a query.
Definition: FromItem.h:50
te::da::Field
The Field class can be used to model an expression that takes part of the output items of a SELECT...
Definition: Field.h:50
te::da::DataSetTypePtr
boost::shared_ptr< DataSetType > DataSetTypePtr
Definition: DataSetType.h:653
te::xml::Reader
This class models a XML reader object.
Definition: Reader.h:55
te::da::DataSetName
A class that models the name of a dataset used in a From clause.
Definition: DataSetName.h:43
te::da::FunctionEncoder
An SQL encoder for general function expressions.
Definition: FunctionEncoder.h:50
te::serialize::xml::ReadDataSetType
TEDATAACCESSEXPORT te::da::DataSetType * ReadDataSetType(te::xml::Reader &reader)
Definition: Serializer.cpp:353
te::da::Select::getGroupBy
const GroupBy * getGroupBy() const
It returns the list of expressions used to condense the result set.
Definition: Select.cpp:962
te::xml::AbstractWriter::writeStartElement
virtual void writeStartElement(const std::string &qName)=0
te::da::DataSourceCatalog
It represents the system catalog of a DataSource.
Definition: DataSourceCatalog.h:68
te::da::Distinct
boost::ptr_vector< Expression > Distinct
A class that models a Distinct clause on a query.
Definition: Distinct.h:37
te::da::SQLFunctionEncoder
A base class for encoders of SQL function expressions.
Definition: SQLFunctionEncoder.h:55
te::common::FindInTerraLibPath
TECOMMONEXPORT std::string FindInTerraLibPath(const std::string &p)
Returns the path relative to a directory or file in the context of TerraLib.
Definition: PlatformUtils.cpp:275
te::da::PropertyName
A class that models the name of any property of an object.
Definition: PropertyName.h:50
te::da::DataSourceCapabilities::setDataSetTypeCapabilities
void setDataSetTypeCapabilities(const DataSetTypeCapabilities &capabilities)
Definition: DataSourceCapabilities.cpp:118
te::da::DataSetType
A class that models the description of a dataset.
Definition: DataSetType.h:72
te::da::DataSourceCapabilities::addSpecificCapability
void addSpecificCapability(const std::string &key, const std::string &value)
Definition: DataSourceCapabilities.cpp:148
te::xml::AbstractWriter::writeValue
virtual void writeValue(const std::string &value)=0
te::da::Field::getExpression
Expression * getExpression() const
It returns the expression set for an output select query.
Definition: Field.cpp:80
te::da::GroupByItem::getExpression
Expression * getExpression() const
It returns the exprsssion to be used to sort the result of a query.
Definition: GroupByItem.cpp:71
te::dt::AbstractData::getTypeCode
virtual int getTypeCode() const =0
It returns the data type code associated to the data value.
te::xml::AbstractWriterFactory::make
static te::xml::AbstractWriter * make()
It creates a new XML writer using the dafault implementation.
Definition: AbstractWriterFactory.cpp:33
te::da::SQLDialect
It represents the SQL query dialect accepted by a given data source.
Definition: SQLDialect.h:55
te::xml::Reader::getAttrAsUInt32
virtual boost::uint32_t getAttrAsUInt32(std::size_t i) const
It returns the attribute value in the case of an element node with valid attributes.
Definition: Reader.cpp:59
te::da::JoinConditionOn::getCondition
Expression * getCondition() const
It returns a pointer to a join condition.
Definition: JoinConditionOn.cpp:72
te::da::OrderBy
boost::ptr_vector< OrderByItem > OrderBy
A class that can be used to model an ORDER BY clause.
Definition: OrderBy.h:37
te::dt::AbstractData::toString
virtual std::string toString() const =0
It returns the data value in a string notation.
te::da::DataSourceCapabilities
A class that represents the known capabilities of a specific data source, i.e. this class informs all...
Definition: DataSourceCapabilities.h:55
te::da::DataSourceCatalog::getNumberOfDataSets
std::size_t getNumberOfDataSets() const
It returns the number of datasets in the catalog.
Definition: DataSourceCatalog.h:515
te::da::DataSourceCapabilities::setAccessPolicy
void setAccessPolicy(const te::common::AccessPolicy &accessPolicy)
Definition: DataSourceCapabilities.cpp:48
te::da::Join::getType
JoinType getType() const
It returns the join type.
Definition: Join.cpp:111
te::xml::ReaderFactory::make
static te::xml::Reader * make()
It creates a new XML reader using the dafault implementation.
Definition: ReaderFactory.cpp:32
te::da::DataSetCapabilities
A class that informs what the dataset implementation of a given data source can perform.
Definition: DataSetCapabilities.h:43
te::xml::AbstractWriter::setRootNamespaceURI
void setRootNamespaceURI(const std::string &uri)
Definition: AbstractWriter.cpp:47
te::xml::AbstractWriter
This class models a XML writer object.
Definition: AbstractWriter.h:49
te::serialize::xml::ReadHaving
TEDATAACCESSEXPORT te::da::Having * ReadHaving(te::xml::Reader &reader)
Definition: Serializer.cpp:1830
TE_TR
#define TE_TR(message)
It marks a string in order to get translated.
Definition: Translator.h:346
te::da::DataTypeCapabilities::setSupport
void setSupport(const int &type, const bool &support)
Definition: DataTypeCapabilities.cpp:345
te::serialize::xml::Read
TEDATAACCESSEXPORT void Read(const std::string &dialectFileName, te::da::DataSourceCapabilities &capabilities, te::da::SQLDialect &dialect)
Definition: Serializer.cpp:411
te::da::DataSourceCapabilities::setSupportDataSetTypePesistenceAPI
void setSupportDataSetTypePesistenceAPI(const bool &support)
Definition: DataSourceCapabilities.cpp:78
te::da::DataSourceCapabilities::setQueryCapabilities
void setQueryCapabilities(const QueryCapabilities &capabilities)
Definition: DataSourceCapabilities.cpp:138
te::da::SQLDialect::insert
void insert(const std::string &funcName, SQLFunctionEncoder *encoder)
It adds a new encoder for a given function.
Definition: SQLDialect.cpp:38
te::serialize::xml::ReadFunction
TEDATAACCESSEXPORT te::da::Function * ReadFunction(te::xml::Reader &reader)
Definition: Serializer.cpp:1723
te::xml::Reader::getElementLocalName
virtual std::string getElementLocalName() const =0
It returns the local part of the element name in the case of an element node.
te::da::DataSourceCatalog::getDataSetType
const DataSetTypePtr & getDataSetType(std::size_t i) const
It returns the i-th dataset schema.
Definition: DataSourceCatalog.cpp:157
te::da::Select::getFrom
const From * getFrom() const
It returns the list of source information to be used by the query.
Definition: Select.cpp:942
te::da::Expression
This is an abstract class that models a query expression.
Definition: Expression.h:47
te::xml::Reader::getAttrAsInt32
virtual boost::int32_t getAttrAsInt32(const std::string &name) const
It returns the attribute value in the case of an element node with valid attributes.
Definition: Reader.cpp:49
te::da::BinaryOpEncoder
A query encoder for binary operations.
Definition: BinaryOpEncoder.h:45
te::da::OrderByItem::getSortOrder
SortOrder getSortOrder() const
It returns the order of sorting: Asc or Desc.
Definition: OrderByItem.cpp:86
te::da::DataSourceCapabilities::setSupportTransactions
void setSupportTransactions(const bool &support)
Definition: DataSourceCapabilities.cpp:58
mydialect
te::da::SQLDialect * mydialect
Definition: OGRDialect.h:1
te::da::DataTypeCapabilities
A class that represents the supported data types of a specific data source.
Definition: DataTypeCapabilities.h:45
te::common::AccessPolicy
AccessPolicy
Supported data access policies (can be used as bitfield).
Definition: Enums.h:40
te::da::DataSourceCapabilities::setSupportPreparedQueryAPI
void setSupportPreparedQueryAPI(const bool &support)
Definition: DataSourceCapabilities.cpp:88
te::xml::AbstractWriter::writeElement
virtual void writeElement(const std::string &qName, const std::string &value)=0
te::serialize::xml::ReadWhere
TEDATAACCESSEXPORT te::da::Where * ReadWhere(te::xml::Reader &reader)
Definition: Serializer.cpp:2085
te::da::QueryCapabilities
A class that informs the query support of a given data source.
Definition: QueryCapabilities.h:48
te::da::DataSourceCapabilities::setSupportDataSetPesistenceAPI
void setSupportDataSetPesistenceAPI(const bool &support)
Definition: DataSourceCapabilities.cpp:68
te::common::Singleton< DataSourceInfoManager >::getInstance
static DataSourceInfoManager & getInstance()
It returns a reference to the singleton instance.
te::xml::AbstractWriter::writeToFile
virtual void writeToFile()=0
te::da::FromItem::getAlias
const std::string & getAlias() const
It returns the alias associated to the source item.
Definition: FromItem.cpp:47
te::da::Literal
This class models a literal value.
Definition: Literal.h:53
capabilities
te::da::DataSourceCapabilities capabilities
Definition: PostGISCapabilities.h:123
te::da::JoinCondition
A condition to be used in a Join clause.
Definition: JoinCondition.h:44
te::serialize::xml::Save
TEDATAACCESSEXPORT void Save(const std::string &fileName)
Definition: Serializer.cpp:205
te::da::Fields
boost::ptr_vector< Field > Fields
Fields is just a boost::ptr_vector of Field pointers.
Definition: Fields.h:37
te::da::JoinType
JoinType
The type of join in a query.
Definition: Enums.h:49
te::serialize::xml::ReadFrom
TEDATAACCESSEXPORT te::da::From * ReadFrom(te::xml::Reader &reader)
Definition: Serializer.cpp:1583
te::da::Where
A class that can be used to model a filter expression that can be applied to a query.
Definition: Where.h:47
te::da::Field::getAlias
std::string * getAlias() const
It returns the alias for the outout expression.
Definition: Field.cpp:90
te::serialize::xml::ReadDistinct
TEDATAACCESSEXPORT te::da::Distinct * ReadDistinct(te::xml::Reader &reader)
Definition: Serializer.cpp:1487
te::dt::AbstractData
A base class for values that can be retrieved from the data access module.
Definition: AbstractData.h:57
te::da::Select::getOffset
std::size_t getOffset() const
It tells the number of rows to skip before starting to return rows.
Definition: Select.cpp:1012
te::da::Where::getExp
Expression * getExp() const
Definition: Where.cpp:60
te::da::Function
A class that models a Function expression.
Definition: Function.h:47
te::da::Select::getFields
const Fields * getFields() const
It returns the list of output expressions used to form the result set.
Definition: Select.cpp:932
te::da::Join
A Join clause combines two FromItems.
Definition: Join.h:50
te::da::Having::getExp
Expression * getExp() const
Definition: Having.cpp:60
te::da::DataSourceCapabilities::setDataSetCapabilities
void setDataSetCapabilities(const DataSetCapabilities &capabilities)
Definition: DataSourceCapabilities.cpp:128
te::da::LiteralDouble
A class that models a literal for double values.
Definition: LiteralDouble.h:43
te::serialize::xml::ReadFromItem
TEDATAACCESSEXPORT te::da::FromItem * ReadFromItem(te::xml::Reader &reader)
Definition: Serializer.cpp:1679
te::dt::CompositeProperty::size
std::size_t size() const
It returns the number of properties of the CompositeProperty.
Definition: CompositeProperty.h:146
Convert2Terralib
te::common::AccessPolicy Convert2Terralib(std::string accessPolicy)
Definition: Serializer.cpp:397
te::da::SortOrder
SortOrder
Sort order type: asc or desc.
Definition: Enums.h:38
te::da::Field::setAlias
void setAlias(std::string *alias)
As you know, sometimes is better to give an alias to an output expression.
Definition: Field.cpp:85
te::xml::Reader::getAttr
virtual std::string getAttr(const std::string &name) const =0
It returns the attribute value in the case of an element node with valid attributes.
te::da::JoinConditionUsing::getNumFields
std::size_t getNumFields() const
It returns the number of fields in this join condition.
Definition: JoinConditionUsing.h:72
te::da::Function::getName
const std::string & getName() const
It returns the function name.
Definition: Function.h:79
te::gm::Geometry::getGeomTypeId
GeomType getGeomTypeId() const
It returns the geometry subclass type identifier.
Definition: Geometry.h:178
te::da::QueryCapabilities::setSupportSQLDialect
void setSupportSQLDialect(const bool &support)
Definition: QueryCapabilities.cpp:52
te::serialize::xml::ReadOrderBy
TEDATAACCESSEXPORT te::da::OrderBy * ReadOrderBy(te::xml::Reader &reader)
Definition: Serializer.cpp:1923
te::serialize::xml::ReadGroupBy
TEDATAACCESSEXPORT te::da::GroupBy * ReadGroupBy(te::xml::Reader &reader)
Definition: Serializer.cpp:1784
te::da::Select
A Select models a query to be used when retrieving data from a DataSource.
Definition: Select.h:65
te::da::DataSetCapabilities::setSupportBidirectionalTraversing
void setSupportBidirectionalTraversing(const bool &support)
Definition: DataSetCapabilities.cpp:51
te::da::From
boost::ptr_vector< FromItem > From
It models the FROM clause for a query.
Definition: From.h:37
te::da::TemplateEncoder
A query encoder for binary operator expressions.
Definition: TemplateEncoder.h:52
te::da::DataSourceCapabilities::setSupportBatchExecutorAPI
void setSupportBatchExecutorAPI(const bool &support)
Definition: DataSourceCapabilities.cpp:98
te::da::Join::getSecond
FromItem * getSecond() const
It returns the second item involved in the join.
Definition: Join.cpp:101
te::serialize::xml::ReadDataSourceCatalog
TEDATAACCESSEXPORT te::da::DataSourceCatalog * ReadDataSourceCatalog(te::xml::Reader &reader)
Definition: Serializer.cpp:285
te::da::Select::getWhere
Where * getWhere() const
It returns the filter condition.
Definition: Select.cpp:952
te::serialize::xml::ReadDialect
TEDATAACCESSEXPORT te::da::SQLDialect * ReadDialect(const std::string &dialectFileName)
Definition: Serializer.cpp:1410
te::da::Join::getCondition
JoinCondition * getCondition() const
It returns the join condition.
Definition: Join.cpp:121
te::xml::AbstractWriter::writeAttribute
virtual void writeAttribute(const std::string &attName, const std::string &value)=0
te::da::JoinConditionUsing
JoinConditionUsing class can be used to model a USING clause in a Join.
Definition: JoinConditionUsing.h:46
te::da::UnaryOpEncoder
A query encoder for unary operator expressions.
Definition: UnaryOpEncoder.h:45
te::serialize::xml::ReadSelect
TEDATAACCESSEXPORT te::da::Select * ReadSelect(te::xml::Reader &reader)
Definition: Serializer.cpp:2007
te::da::DataSourceCapabilities::setDataTypeCapabilities
void setDataTypeCapabilities(const DataTypeCapabilities &capabilities)
Definition: DataSourceCapabilities.cpp:108
te::da::Select::getHaving
const Having * getHaving() const
It returns the list of expressions used to eliminate group row that doesn't satisfy the condition...
Definition: Select.cpp:972
te::xml::Reader::getNodeType
virtual NodeType getNodeType() const =0
It return the type of node read.
te::da::DataSetTypeCapabilities::setSupportPrimaryKey
void setSupportPrimaryKey(const bool &support)
Definition: DataSetTypeCapabilities.cpp:55
te::da::Select::getLimit
std::size_t getLimit() const
It tells the maximum number of rows to return.
Definition: Select.cpp:1002
te::xml::Reader::getElementValue
virtual std::string getElementValue() const =0
It returns the element data value in the case of VALUE node.
te::da::DataSetName::getName
const std::string & getName() const
It returns the dataset name.
Definition: DataSetName.cpp:57
te::serialize::xml::ReadFields
TEDATAACCESSEXPORT te::da::Fields * ReadFields(te::xml::Reader &reader)
Definition: Serializer.cpp:1523
te::xml::AbstractWriter::writeEndElement
virtual void writeEndElement(const std::string &qName)=0
te::da::DataSourceInfo
A class that represents a data source component.
Definition: DataSourceInfo.h:57
te::xml::AbstractWriter::writeStartDocument
virtual void writeStartDocument(const std::string &encoding, const std::string &standalone)=0
te::da::JoinConditionOn
JoinConditionOn is a boolean expression and it specifies which items in a join are considered to matc...
Definition: JoinConditionOn.h:49
te::da::Expression::clone
virtual Expression * clone() const =0
It creates a new copy of this expression.
te::da::OrderByItem
A class that can be used in an ORDER BY clause to sort the items of a resulting query.
Definition: OrderByItem.h:53
te::da::OrderByItem::getExpression
Expression * getExpression() const
It returns the exprsssion to be used to sort the result of a query.
Definition: OrderByItem.cpp:76
te::xml::Reader::next
virtual bool next()=0
It gets the next event to be read.
te::da::Literal::getValue
te::dt::AbstractData * getValue() const
It returns the value associated to the literal.
Definition: Literal.cpp:65
te::da::BinaryFunction
A base class for binary functions.
Definition: BinaryFunction.h:43
te::da::Function::getNumArgs
std::size_t getNumArgs() const
It returns the number of arguments informed to the function.
Definition: Function.cpp:62
te::serialize::xml::ReadPropertyName
TEDATAACCESSEXPORT te::da::PropertyName * ReadPropertyName(te::xml::Reader &reader)
Definition: Serializer.cpp:1987
te::dt::Property::getId
unsigned int getId() const
It returns the property identifier.
Definition: Property.h:109
te::dt::Convert2Terralib
TEDATATYPEEXPORT int Convert2Terralib(const std::string &dataType)
It convert a string to a DataType.
Definition: Utils.cpp:42
te::serialize::xml::ReadLiteral
TEDATAACCESSEXPORT te::da::Literal * ReadLiteral(te::xml::Reader &reader)
Definition: Serializer.cpp:1859
te::da::Join::getFirst
FromItem * getFirst() const
It returns the first from item involved in the join.
Definition: Join.cpp:91
te::da::DataSourceInfoPtr
boost::shared_ptr< DataSourceInfo > DataSourceInfoPtr
Definition: DataSourceInfo.h:105
te::serialize::xml::ReadDataSourceInfo
TEDATAACCESSEXPORT void ReadDataSourceInfo(const std::string &datasourcesFileName)
Definition: Serializer.cpp:90
te::da::DataSetType::getTitle
const std::string & getTitle() const
A human descriptive title for the DataSetType.
Definition: DataSetType.h:130
te::da::LiteralGeom
A class that models a literal for Geometry values.
Definition: LiteralGeom.h:46
te::da::LiteralString
This class models a string Literal value.
Definition: LiteralString.h:46
te::dt::Property::getName
const std::string & getName() const
It returns the property name.
Definition: Property.h:127
te::gm::WKTReader::read
static Geometry * read(const char *wkt)
It returns a valid Geometry from a given WKT.
Definition: WKTReader.cpp:32