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