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