Debian Codegraph @

ogr/ogrsf_frmts/hana/ogrhanalayer.cpp

raw
1 /******************************************************************************
2 *
3 * Project: SAP HANA Spatial Driver
4 * Purpose: OGRHanaLayer class implementation
5 * Author: Maxim Rylov
6 *
7 ******************************************************************************
8 * Copyright (c) 2020, SAP SE
9 *
10 * SPDX-License-Identifier: MIT
11 ****************************************************************************/
12
13 #include "ogr_hana.h"
14 #include "ogrhanafeaturewriter.h"
15 #include "ogrhanautils.h"
16
17 #include <algorithm>
18 #include <cmath>
19 #include <limits>
20 #include <sstream>
21 #include <memory>
22
23 #include "odbc/Exception.h"
24 #include "odbc/PreparedStatement.h"
25 #include "odbc/ResultSet.h"
26 #include "odbc/Statement.h"
27 #include "odbc/Types.h"
28
29 namespace OGRHANA
30 {
31 namespace
32 {
33 /************************************************************************/
34 /* Helper methods */
35 /************************************************************************/
36
37 CPLString BuildQuery(const char *source, const char *columns, const char *where,
38 const char *orderBy, int limit)
39 {
40 std::ostringstream os;
41 os << "SELECT " << columns << " FROM (" << source << ")";
42 if (where != nullptr && strlen(where) > 0)
43 os << " WHERE " << where;
44 if (orderBy != nullptr && strlen(orderBy) > 0)
45 os << " ORDER BY " << orderBy;
46 if (limit >= 0)
47 os << " LIMIT " << std::to_string(limit);
48 return os.str();
49 }
50
51 CPLString BuildQuery(const char *source, const char *columns)
52 {
53 return BuildQuery(source, columns, nullptr, nullptr, -1);
54 }
55
56 CPLString BuildSpatialFilter(int dbVersion, const OGRGeometry &geom,
57 const CPLString &clmName, int srid)
58 {
59 OGREnvelope env;
60 geom.getEnvelope(&env);
61
62 if ((std::isinf(env.MinX) || std::isinf(env.MinY) || std::isinf(env.MaxX) ||
63 std::isinf(env.MaxY)))
64 return "";
65
66 auto clampValue = [](double v)
67 {
68 constexpr double MAX_VALUE = 1e+150;
69 if (v < -MAX_VALUE)
70 return -MAX_VALUE;
71 else if (v > MAX_VALUE)
72 return MAX_VALUE;
73 return v;
74 };
75
76 double minX = clampValue(env.MinX);
77 double minY = clampValue(env.MinY);
78 double maxX = clampValue(env.MaxX);
79 double maxY = clampValue(env.MaxY);
80
81 // TODO: add support for non-rectangular filter, see m_bFilterIsEnvelope
82 // flag.
83 if (dbVersion == 1)
84 return CPLString().Printf(
85 "\"%s\".ST_IntersectsRect(ST_GeomFromText('POINT(%.17g %.17g)', "
86 "%d), ST_GeomFromText('POINT(%.17g %.17g)', %d)) = 1",
87 clmName.c_str(), minX, minY, srid, maxX, maxY, srid);
88 else
89 return CPLString().Printf(
90 "\"%s\".ST_IntersectsRectPlanar(ST_GeomFromText('POINT(%.17g "
91 "%.17g)', %d), ST_GeomFromText('POINT(%.17g %.17g)', %d)) = 1",
92 clmName.c_str(), minX, minY, srid, maxX, maxY, srid);
93 }
94
95 std::unique_ptr<OGRFieldDefn>
96 CreateFieldDefn(const AttributeColumnDescription &columnDesc)
97 {
98 bool setFieldSize = false;
99 bool setFieldPrecision = false;
100
101 OGRFieldType ogrFieldType = OFTString;
102 OGRFieldSubType ogrFieldSubType = OGRFieldSubType::OFSTNone;
103 int width = columnDesc.length;
104
105 switch (columnDesc.type)
106 {
107 case QGRHanaDataTypes::Bit:
108 case QGRHanaDataTypes::Boolean:
109 ogrFieldType = columnDesc.isArray ? OFTIntegerList : OFTInteger;
110 ogrFieldSubType = OGRFieldSubType::OFSTBoolean;
111 break;
112 case QGRHanaDataTypes::TinyInt:
113 case QGRHanaDataTypes::SmallInt:
114 ogrFieldType = columnDesc.isArray ? OFTIntegerList : OFTInteger;
115 ogrFieldSubType = OGRFieldSubType::OFSTInt16;
116 break;
117 case QGRHanaDataTypes::Integer:
118 ogrFieldType = columnDesc.isArray ? OFTIntegerList : OFTInteger;
119 break;
120 case QGRHanaDataTypes::BigInt:
121 ogrFieldType = columnDesc.isArray ? OFTInteger64List : OFTInteger64;
122 break;
123 case QGRHanaDataTypes::Double:
124 case QGRHanaDataTypes::Real:
125 case QGRHanaDataTypes::Float:
126 ogrFieldType = columnDesc.isArray ? OFTRealList : OFTReal;
127 if (columnDesc.type != QGRHanaDataTypes::Double)
128 ogrFieldSubType = OGRFieldSubType::OFSTFloat32;
129 break;
130 case QGRHanaDataTypes::Decimal:
131 case QGRHanaDataTypes::Numeric:
132 ogrFieldType = columnDesc.isArray ? OFTRealList : OFTReal;
133 setFieldPrecision = true;
134 break;
135 case QGRHanaDataTypes::Char:
136 case QGRHanaDataTypes::VarChar:
137 case QGRHanaDataTypes::LongVarChar:
138 case QGRHanaDataTypes::WChar:
139 case QGRHanaDataTypes::WVarChar:
140 case QGRHanaDataTypes::WLongVarChar:
141 // Note: OFTWideString is deprecated
142 ogrFieldType = columnDesc.isArray ? OFTStringList : OFTString;
143 setFieldSize = true;
144 break;
145 case QGRHanaDataTypes::Date:
146 case QGRHanaDataTypes::TypeDate:
147 ogrFieldType = OFTDate;
148 break;
149 case QGRHanaDataTypes::Time:
150 case QGRHanaDataTypes::TypeTime:
151 ogrFieldType = OFTTime;
152 break;
153 case QGRHanaDataTypes::Timestamp:
154 case QGRHanaDataTypes::TypeTimestamp:
155 ogrFieldType = OFTDateTime;
156 break;
157 case QGRHanaDataTypes::Binary:
158 case QGRHanaDataTypes::VarBinary:
159 case QGRHanaDataTypes::LongVarBinary:
160 ogrFieldType = OFTBinary;
161 setFieldSize = true;
162 break;
163 case QGRHanaDataTypes::RealVector:
164 ogrFieldType = OFTBinary;
165 // The .fvecs format is used for REAL_VECTOR with the dimension
166 // lying in the range [1,65000].
167 width = (columnDesc.precision == 0)
168 ? 65000
169 : 4 * (columnDesc.precision + 1);
170 setFieldSize = true;
171 break;
172 default:
173 break;
174 }
175
176 if (columnDesc.isArray && !IsArrayField(ogrFieldType))
177 CPLError(CE_Failure, CPLE_AppDefined,
178 "Array of type %s in column %s is not supported",
179 columnDesc.typeName.c_str(), columnDesc.name.c_str());
180
181 auto field =
182 std::make_unique<OGRFieldDefn>(columnDesc.name.c_str(), ogrFieldType);
183 field->SetSubType(ogrFieldSubType);
184 field->SetNullable(columnDesc.isNullable);
185 if (!columnDesc.isArray)
186 {
187 if (setFieldSize)
188 field->SetWidth(width);
189 if (setFieldPrecision)
190 {
191 field->SetWidth(columnDesc.precision);
192 field->SetPrecision(columnDesc.scale);
193 }
194 }
195 if (columnDesc.defaultValue.empty())
196 field->SetDefault(nullptr);
197 else
198 field->SetDefault(columnDesc.defaultValue.c_str());
199 return field;
200 }
201
202 OGRGeometry *CreateGeometryFromWkb(const void *data, std::size_t size)
203 {
204 if (size > static_cast<std::size_t>(std::numeric_limits<int>::max()))
205 CPLError(CE_Failure, CPLE_AppDefined, "createFromWkb(): %s",
206 "Geometry size is larger than maximum integer value");
207
208 int len = static_cast<int>(size);
209
210 OGRGeometry *geom = nullptr;
211 OGRErr err = OGRGeometryFactory::createFromWkb(data, nullptr, &geom, len);
212
213 if (OGRERR_NONE == err)
214 return geom;
215
216 auto cplError = [](const char *message)
217 { CPLError(CE_Failure, CPLE_AppDefined, "ReadFeature(): %s", message); };
218
219 switch (err)
220 {
221 case OGRERR_NOT_ENOUGH_DATA:
222 cplError("Not enough data to deserialize");
223 return nullptr;
224 case OGRERR_UNSUPPORTED_GEOMETRY_TYPE:
225 cplError("Unsupported geometry type");
226 return nullptr;
227 case OGRERR_CORRUPT_DATA:
228 cplError("Corrupt data");
229 return nullptr;
230 default:
231 cplError("Unrecognized error");
232 return nullptr;
233 }
234 }
235
236 } // anonymous namespace
237
238 /************************************************************************/
239 /* OGRHanaLayer() */
240 /************************************************************************/
241
242 OGRHanaLayer::OGRHanaLayer(OGRHanaDataSource *datasource)
243 : dataSource_(datasource), rawQuery_(""), queryStatement_(""),
244 whereClause_("")
245 {
246 }
247
248 /************************************************************************/
249 /* ~OGRHanaLayer() */
250 /************************************************************************/
251
252 OGRHanaLayer::~OGRHanaLayer()
253 {
254 if (featureDefn_)
255 featureDefn_->Release();
256 }
257
258 void OGRHanaLayer::EnsureInitialized()
259 {
260 if (initialized_)
261 return;
262
263 OGRErr err = Initialize();
264 if (OGRERR_NONE != err)
265 {
266 CPLError(CE_Failure, CPLE_AppDefined, "Failed to initialize layer: %s",
267 GetName());
268 }
269 initialized_ = (OGRERR_NONE == err);
270 }
271
272 /************************************************************************/
273 /* ClearQueryStatement() */
274 /************************************************************************/
275
276 void OGRHanaLayer::ClearQueryStatement()
277 {
278 queryStatement_.clear();
279 }
280
281 /************************************************************************/
282 /* GetQueryStatement() */
283 /************************************************************************/
284
285 const CPLString &OGRHanaLayer::GetQueryStatement()
286 {
287 if (!queryStatement_.empty())
288 return queryStatement_;
289
290 EnsureInitialized();
291
292 if (!geomColumns_.empty())
293 {
294 std::vector<CPLString> columns;
295 for (const GeometryColumnDescription &geometryColumnDesc : geomColumns_)
296 columns.push_back(QuotedIdentifier(geometryColumnDesc.name) +
297 ".ST_AsBinary() AS " +
298 QuotedIdentifier(geometryColumnDesc.name));
299
300 for (const AttributeColumnDescription &attributeColumnDesc :
301 attrColumns_)
302 columns.push_back(QuotedIdentifier(attributeColumnDesc.name));
303
304 queryStatement_ = CPLString().Printf(
305 "SELECT %s FROM (%s) %s", JoinStrings(columns, ", ").c_str(),
306 rawQuery_.c_str(), whereClause_.c_str());
307 }
308 else
309 {
310 if (whereClause_.empty())
311 queryStatement_ = rawQuery_;
312 else
313 queryStatement_ =
314 CPLString().Printf("SELECT * FROM (%s) %s", rawQuery_.c_str(),
315 whereClause_.c_str());
316 }
317
318 return queryStatement_;
319 }
320
321 /************************************************************************/
322 /* BuildWhereClause() */
323 /************************************************************************/
324
325 void OGRHanaLayer::BuildWhereClause()
326 {
327 whereClause_ = "";
328
329 CPLString spatialFilter;
330 if (m_poFilterGeom != nullptr)
331 {
332 EnsureInitialized();
333
334 OGRGeomFieldDefn *geomFieldDefn = nullptr;
335 if (featureDefn_->GetGeomFieldCount() != 0)
336 geomFieldDefn = featureDefn_->GetGeomFieldDefn(m_iGeomFieldFilter);
337
338 if (geomFieldDefn != nullptr)
339 {
340 const GeometryColumnDescription &geomClmDesc =
341 geomColumns_[static_cast<std::size_t>(m_iGeomFieldFilter)];
342 spatialFilter = BuildSpatialFilter(
343 dataSource_->GetHanaVersion().major(), *m_poFilterGeom,
344 geomClmDesc.name, geomClmDesc.srid);
345 }
346 }
347
348 if (!attrFilter_.empty())
349 {
350 whereClause_ = " WHERE " + attrFilter_;
351 if (!spatialFilter.empty())
352 whereClause_ += " AND " + spatialFilter;
353 }
354 else if (!spatialFilter.empty())
355 whereClause_ = " WHERE " + spatialFilter;
356 }
357
358 /************************************************************************/
359 /* EnsureBufferCapacity() */
360 /************************************************************************/
361
362 void OGRHanaLayer::EnsureBufferCapacity(std::size_t size)
363 {
364 if (size > dataBuffer_.size())
365 dataBuffer_.resize(size);
366 }
367
368 /************************************************************************/
369 /* GetNextFeatureInternal() */
370 /************************************************************************/
371
372 OGRFeature *OGRHanaLayer::GetNextFeatureInternal()
373 {
374 if (resultSet_.isNull())
375 {
376 const CPLString &queryStatement = GetQueryStatement();
377 CPLAssert(!queryStatement.empty());
378
379 try
380 {
381 odbc::StatementRef stmt = dataSource_->CreateStatement();
382 resultSet_ = stmt->executeQuery(queryStatement.c_str());
383 }
384 catch (const odbc::Exception &ex)
385 {
386 CPLError(CE_Failure, CPLE_AppDefined,
387 "Failed to execute query : %s", ex.what());
388 return nullptr;
389 }
390 }
391
392 return ReadFeature();
393 }
394
395 /************************************************************************/
396 /* GetGeometryColumnSrid() */
397 /************************************************************************/
398
399 int OGRHanaLayer::GetGeometryColumnSrid(int columnIndex) const
400 {
401 if (columnIndex < 0 ||
402 static_cast<std::size_t>(columnIndex) >= geomColumns_.size())
403 return -1;
404 return geomColumns_[static_cast<std::size_t>(columnIndex)].srid;
405 }
406
407 /************************************************************************/
408 /* ReadFeature() */
409 /************************************************************************/
410
411 OGRFeature *OGRHanaLayer::ReadFeature()
412 {
413 if (!resultSet_->next())
414 return nullptr;
415
416 auto feature = std::make_unique<OGRFeature>(featureDefn_);
417 feature->SetFID(nextFeatureId_++);
418
419 unsigned short paramIndex = 0;
420
421 // Read geometries
422 for (std::size_t i = 0; i < geomColumns_.size(); ++i)
423 {
424 ++paramIndex;
425 int geomIndex = static_cast<int>(i);
426
427 OGRGeomFieldDefn *geomFieldDef =
428 featureDefn_->GetGeomFieldDefn(geomIndex);
429
430 if (geomFieldDef->IsIgnored())
431 continue;
432
433 std::size_t bufLength = resultSet_->getBinaryLength(paramIndex);
434 if (bufLength == 0 || bufLength == odbc::ResultSet::NULL_DATA)
435 {
436 feature->SetGeomFieldDirectly(geomIndex, nullptr);
437 continue;
438 }
439
440 OGRGeometry *geom = nullptr;
441 if (bufLength != odbc::ResultSet::UNKNOWN_LENGTH)
442 {
443 EnsureBufferCapacity(bufLength);
444 resultSet_->getBinaryData(paramIndex, dataBuffer_.data(),
445 bufLength);
446 geom =
447 CreateGeometryFromWkb(dataBuffer_.data(), dataBuffer_.size());
448 }
449 else
450 {
451 odbc::Binary wkb = resultSet_->getBinary(paramIndex);
452 if (!wkb.isNull() && wkb->size() > 0)
453 geom = CreateGeometryFromWkb(
454 static_cast<const void *>(wkb->data()), wkb->size());
455 }
456
457 if (geom != nullptr)
458 geom->assignSpatialReference(geomFieldDef->GetSpatialRef());
459 feature->SetGeomFieldDirectly(geomIndex, geom);
460 }
461
462 // Read feature attributes
463 OGRHanaFeatureWriter featWriter(*feature);
464 int fieldIndex = -1;
465 for (const AttributeColumnDescription &clmDesc : attrColumns_)
466 {
467 ++paramIndex;
468
469 if (clmDesc.isFeatureID)
470 {
471 if (clmDesc.type == QGRHanaDataTypes::Integer)
472 {
473 odbc::Int val = resultSet_->getInt(paramIndex);
474 if (!val.isNull())
475 feature->SetFID(static_cast<GIntBig>(*val));
476 }
477 else if (clmDesc.type == QGRHanaDataTypes::BigInt)
478 {
479 odbc::Long val = resultSet_->getLong(paramIndex);
480 if (!val.isNull())
481 feature->SetFID(static_cast<GIntBig>(*val));
482 }
483 continue;
484 }
485
486 ++fieldIndex;
487
488 OGRFieldDefn *fieldDefn = featureDefn_->GetFieldDefn(fieldIndex);
489 if (fieldDefn->IsIgnored())
490 continue;
491
492 if (clmDesc.isArray)
493 {
494 odbc::Binary val = resultSet_->getBinary(paramIndex);
495 if (val.isNull())
496 {
497 feature->SetFieldNull(fieldIndex);
498 continue;
499 }
500
501 switch (clmDesc.type)
502 {
503 case QGRHanaDataTypes::Boolean:
504 featWriter.SetFieldValueAsArray<uint8_t, int32_t>(
505 fieldIndex, val);
506 break;
507 case QGRHanaDataTypes::TinyInt:
508 featWriter.SetFieldValueAsArray<uint8_t, int32_t>(
509 fieldIndex, val);
510 break;
511 case QGRHanaDataTypes::SmallInt:
512 featWriter.SetFieldValueAsArray<int16_t, int32_t>(
513 fieldIndex, val);
514 break;
515 case QGRHanaDataTypes::Integer:
516 featWriter.SetFieldValueAsArray<int32_t, int32_t>(
517 fieldIndex, val);
518 break;
519 case QGRHanaDataTypes::BigInt:
520 featWriter.SetFieldValueAsArray<GIntBig, GIntBig>(
521 fieldIndex, val);
522 break;
523 case QGRHanaDataTypes::Float:
524 case QGRHanaDataTypes::Real:
525 featWriter.SetFieldValueAsArray<float, double>(fieldIndex,
526 val);
527 break;
528 case QGRHanaDataTypes::Double:
529 featWriter.SetFieldValueAsArray<double, double>(fieldIndex,
530 val);
531 break;
532 case QGRHanaDataTypes::Char:
533 case QGRHanaDataTypes::VarChar:
534 case QGRHanaDataTypes::LongVarChar:
535 case QGRHanaDataTypes::WChar:
536 case QGRHanaDataTypes::WVarChar:
537 case QGRHanaDataTypes::WLongVarChar:
538 featWriter.SetFieldValueAsStringArray(fieldIndex, val);
539 break;
540 }
541
542 continue;
543 }
544
545 switch (clmDesc.type)
546 {
547 case QGRHanaDataTypes::Bit:
548 case QGRHanaDataTypes::Boolean:
549 {
550 odbc::Boolean val = resultSet_->getBoolean(paramIndex);
551 featWriter.SetFieldValue(fieldIndex, val);
552 }
553 break;
554 case QGRHanaDataTypes::TinyInt:
555 {
556 odbc::Byte val = resultSet_->getByte(paramIndex);
557 featWriter.SetFieldValue(fieldIndex, val);
558 }
559 break;
560 case QGRHanaDataTypes::SmallInt:
561 {
562 odbc::Short val = resultSet_->getShort(paramIndex);
563 featWriter.SetFieldValue(fieldIndex, val);
564 }
565 break;
566 case QGRHanaDataTypes::Integer:
567 {
568 odbc::Int val = resultSet_->getInt(paramIndex);
569 featWriter.SetFieldValue(fieldIndex, val);
570 }
571 break;
572 case QGRHanaDataTypes::BigInt:
573 {
574 odbc::Long val = resultSet_->getLong(paramIndex);
575 featWriter.SetFieldValue(fieldIndex, val);
576 }
577 break;
578 case QGRHanaDataTypes::Real:
579 case QGRHanaDataTypes::Float:
580 {
581 odbc::Float val = resultSet_->getFloat(paramIndex);
582 featWriter.SetFieldValue(fieldIndex, val);
583 }
584 break;
585 case QGRHanaDataTypes::Double:
586 {
587 odbc::Double val = resultSet_->getDouble(paramIndex);
588 featWriter.SetFieldValue(fieldIndex, val);
589 }
590 break;
591 case QGRHanaDataTypes::Decimal:
592 case QGRHanaDataTypes::Numeric:
593 {
594 odbc::Decimal val = resultSet_->getDecimal(paramIndex);
595 featWriter.SetFieldValue(fieldIndex, val);
596 }
597 break;
598 case QGRHanaDataTypes::Char:
599 case QGRHanaDataTypes::VarChar:
600 case QGRHanaDataTypes::LongVarChar:
601 // Note: NVARCHAR data type is converted to UTF-8 on the HANA side
602 // when using a connection setting CHAR_AS_UTF8=1.
603 case QGRHanaDataTypes::WChar:
604 case QGRHanaDataTypes::WVarChar:
605 case QGRHanaDataTypes::WLongVarChar:
606 {
607 std::size_t len = resultSet_->getStringLength(paramIndex);
608 if (len == odbc::ResultSet::NULL_DATA)
609 feature->SetFieldNull(fieldIndex);
610 else if (len == 0)
611 feature->SetField(fieldIndex, "");
612 else if (len != odbc::ResultSet::UNKNOWN_LENGTH)
613 {
614 EnsureBufferCapacity(len + 1);
615 resultSet_->getStringData(paramIndex, dataBuffer_.data(),
616 len + 1);
617 featWriter.SetFieldValue(fieldIndex, dataBuffer_.data());
618 }
619 else
620 {
621 odbc::String data = resultSet_->getString(paramIndex);
622 featWriter.SetFieldValue(fieldIndex, data);
623 }
624 }
625 break;
626 case QGRHanaDataTypes::Binary:
627 case QGRHanaDataTypes::VarBinary:
628 case QGRHanaDataTypes::LongVarBinary:
629 case QGRHanaDataTypes::RealVector:
630 {
631 std::size_t len = resultSet_->getBinaryLength(paramIndex);
632 if (len == 0)
633 feature->SetField(fieldIndex, 0,
634 static_cast<GByte *>(nullptr));
635 else if (len == odbc::ResultSet::NULL_DATA)
636 feature->SetFieldNull(fieldIndex);
637 else if (len != odbc::ResultSet::UNKNOWN_LENGTH)
638 {
639 EnsureBufferCapacity(len);
640 resultSet_->getBinaryData(paramIndex, dataBuffer_.data(),
641 len);
642 featWriter.SetFieldValue(fieldIndex, dataBuffer_.data(),
643 len);
644 }
645 else
646 {
647 odbc::Binary binData = resultSet_->getBinary(paramIndex);
648 featWriter.SetFieldValue(fieldIndex, binData);
649 }
650 }
651 break;
652 case QGRHanaDataTypes::Date:
653 case QGRHanaDataTypes::TypeDate:
654 {
655 odbc::Date date = resultSet_->getDate(paramIndex);
656 featWriter.SetFieldValue(fieldIndex, date);
657 }
658 break;
659 case QGRHanaDataTypes::Time:
660 case QGRHanaDataTypes::TypeTime:
661 {
662 odbc::Time time = resultSet_->getTime(paramIndex);
663 featWriter.SetFieldValue(fieldIndex, time);
664 }
665 break;
666 case QGRHanaDataTypes::Timestamp:
667 case QGRHanaDataTypes::TypeTimestamp:
668 {
669 odbc::Timestamp timestamp =
670 resultSet_->getTimestamp(paramIndex);
671 featWriter.SetFieldValue(fieldIndex, timestamp);
672 }
673 break;
674 default:
675 break;
676 }
677 }
678
679 return feature.release();
680 }
681
682 /************************************************************************/
683 /* InitFeatureDefinition() */
684 /************************************************************************/
685
686 OGRErr OGRHanaLayer::InitFeatureDefinition(const CPLString &schemaName,
687 const CPLString &tableName,
688 const CPLString &query,
689 const CPLString &featureDefName)
690 {
691 attrColumns_.clear();
692 geomColumns_.clear();
693 fidFieldIndex_ = OGRNullFID;
694 fidFieldName_.clear();
695 featureDefn_ = new OGRFeatureDefn(featureDefName.c_str());
696 featureDefn_->Reference();
697
698 std::vector<ColumnDescription> columnDescriptions;
699 OGRErr err =
700 dataSource_->GetQueryColumns(schemaName, query, columnDescriptions);
701 if (err != OGRERR_NONE)
702 return err;
703
704 std::vector<CPLString> primKeys =
705 dataSource_->GetTablePrimaryKeys(schemaName, tableName);
706
707 if (featureDefn_->GetGeomFieldCount() == 1)
708 featureDefn_->DeleteGeomFieldDefn(0);
709
710 for (const ColumnDescription &clmDesc : columnDescriptions)
711 {
712 if (clmDesc.isGeometry)
713 {
714 const GeometryColumnDescription &geometryColumnDesc =
715 clmDesc.geometryDescription;
716
717 auto geomFieldDefn = std::make_unique<OGRGeomFieldDefn>(
718 geometryColumnDesc.name.c_str(), geometryColumnDesc.type);
719 geomFieldDefn->SetNullable(geometryColumnDesc.isNullable);
720
721 if (geometryColumnDesc.srid >= 0)
722 {
723 OGRSpatialReference *srs =
724 dataSource_->GetSrsById(geometryColumnDesc.srid);
725 geomFieldDefn->SetSpatialRef(srs);
726 srs->Release();
727 }
728 geomColumns_.push_back(geometryColumnDesc);
729 featureDefn_->AddGeomFieldDefn(std::move(geomFieldDefn));
730 continue;
731 }
732
733 AttributeColumnDescription attributeColumnDesc =
734 clmDesc.attributeDescription;
735 auto field = CreateFieldDefn(attributeColumnDesc);
736
737 if ((field->GetType() == OFTInteger ||
738 field->GetType() == OFTInteger64) &&
739 (fidFieldIndex_ == OGRNullFID && primKeys.size() > 0))
740 {
741 for (const CPLString &key : primKeys)
742 {
743 if (key.compare(attributeColumnDesc.name) == 0)
744 {
745 fidFieldIndex_ = static_cast<int>(attrColumns_.size());
746 fidFieldName_ = field->GetNameRef();
747 attributeColumnDesc.isFeatureID = true;
748 break;
749 }
750 }
751 }
752
753 if (!attributeColumnDesc.isFeatureID)
754 featureDefn_->AddFieldDefn(field.get());
755 attrColumns_.push_back(std::move(attributeColumnDesc));
756 }
757
758 return OGRERR_NONE;
759 }
760
761 /************************************************************************/
762 /* ReadGeometryExtent() */
763 /************************************************************************/
764
765 void OGRHanaLayer::ReadGeometryExtent(int geomField, OGREnvelope *extent,
766 int force)
767 {
768 EnsureInitialized();
769
770 OGRGeomFieldDefn *geomFieldDef = featureDefn_->GetGeomFieldDefn(geomField);
771 const char *clmName = geomFieldDef->GetNameRef();
772 odbc::PreparedStatementRef stmt;
773 if (!force && IsTableLayer())
774 {
775 auto names = dataSource_->FindSchemaAndTableNames(rawQuery_.c_str());
776 stmt = dataSource_->PrepareStatement(
777 "SELECT MIN_X, MIN_Y, MAX_X, MAX_Y FROM "
778 "SYS.M_ST_GEOMETRY_COLUMNS WHERE SCHEMA_NAME=? AND TABLE_NAME=? "
779 "AND COLUMN_NAME=?");
780 stmt->setString(1, names.first == ""
781 ? odbc::String(dataSource_->schemaName_)
782 : odbc::String(names.first));
783 stmt->setString(2, odbc::String(names.second));
784 stmt->setString(3, odbc::String(clmName));
785 }
786 else
787 {
788 int srid = GetGeometryColumnSrid(geomField);
789 if (dataSource_->IsSrsRoundEarth(srid))
790 {
791 CPLString quotedClmName = QuotedIdentifier(clmName);
792 bool hasSrsPlanarEquivalent =
793 dataSource_->HasSrsPlanarEquivalent(srid);
794 CPLString geomColumn =
795 !hasSrsPlanarEquivalent
796 ? quotedClmName
797 : CPLString().Printf("%s.ST_SRID(%d)",
798 quotedClmName.c_str(),
799 ToPlanarSRID(srid));
800 CPLString columns = CPLString().Printf(
801 "MIN(%s.ST_XMin()), MIN(%s.ST_YMin()), MAX(%s.ST_XMax()), "
802 "MAX(%s.ST_YMax())",
803 geomColumn.c_str(), geomColumn.c_str(), geomColumn.c_str(),
804 geomColumn.c_str());
805 stmt = dataSource_->PrepareStatement(
806 BuildQuery(rawQuery_.c_str(), columns.c_str()));
807 }
808 else
809 {
810 CPLString columns =
811 CPLString().Printf("ST_EnvelopeAggr(%s) AS ext",
812 QuotedIdentifier(clmName).c_str());
813 CPLString subQuery = BuildQuery(rawQuery_.c_str(), columns);
814 stmt = dataSource_->PrepareStatement(CPLString().Printf(
815 "SELECT "
816 "ext.ST_XMin(),ext.ST_YMin(),ext.ST_XMax(),ext.ST_YMax() "
817 "FROM (%s)",
818 subQuery.c_str()));
819 }
820 }
821
822 bool set = false;
823 extent->MinX = 0.0;
824 extent->MaxX = 0.0;
825 extent->MinY = 0.0;
826 extent->MaxY = 0.0;
827
828 odbc::ResultSetRef rsExtent = stmt->executeQuery();
829 if (rsExtent->next())
830 {
831 odbc::Double val = rsExtent->getDouble(1);
832 if (!val.isNull())
833 {
834 extent->MinX = *val;
835 extent->MinY = *rsExtent->getDouble(2);
836 extent->MaxX = *rsExtent->getDouble(3);
837 extent->MaxY = *rsExtent->getDouble(4);
838 set = true;
839 }
840 }
841
842 rsExtent->close();
843 if (!set && !force)
844 ReadGeometryExtent(geomField, extent, true);
845 }
846
847 bool OGRHanaLayer::IsFastExtentAvailable() const
848 {
849 if (geomColumns_.empty())
850 return false;
851
852 switch (dataSource_->GetHanaVersion().major())
853 {
854 case 2:
855 return dataSource_->GetHanaVersion() >= HanaVersion(2, 0, 80);
856 case 4:
857 return dataSource_->GetHanaCloudVersion() >=
858 HanaVersion(2024, 2, 0);
859 }
860
861 return false;
862 }
863
864 /************************************************************************/
865 /* ResetReading() */
866 /************************************************************************/
867
868 void OGRHanaLayer::ResetReading()
869 {
870 nextFeatureId_ = 0;
871 resultSet_.reset();
872 }
873
874 /************************************************************************/
875 /* IGetExtent() */
876 /************************************************************************/
877
878 OGRErr OGRHanaLayer::IGetExtent(int iGeomField, OGREnvelope *extent, bool force)
879 {
880 try
881 {
882 if (!force)
883 force = !IsFastExtentAvailable();
884 ReadGeometryExtent(iGeomField, extent, force);
885
886 return OGRERR_NONE;
887 }
888 catch (const std::exception &ex)
889 {
890 CPLString clmName =
891 (iGeomField < static_cast<int>(geomColumns_.size()))
892 ? geomColumns_[static_cast<std::size_t>(geomColumns_.size())]
893 .name
894 : "unknown column";
895 CPLError(CE_Failure, CPLE_AppDefined,
896 "Unable to query extent of '%s' using fast method: %s",
897 clmName.c_str(), ex.what());
898 }
899
900 return OGRLayer::IGetExtent(iGeomField, extent, force);
901 }
902
903 /************************************************************************/
904 /* GetFeatureCount() */
905 /************************************************************************/
906
907 GIntBig OGRHanaLayer::GetFeatureCount(CPL_UNUSED int force)
908 {
909 EnsureInitialized();
910
911 GIntBig ret = 0;
912 CPLString sql = CPLString().Printf("SELECT COUNT(*) FROM (%s) AS tmp",
913 GetQueryStatement().c_str());
914 odbc::StatementRef stmt = dataSource_->CreateStatement();
915 odbc::ResultSetRef rs = stmt->executeQuery(sql.c_str());
916 if (rs->next())
917 ret = *rs->getLong(1);
918 rs->close();
919 return ret;
920 }
921
922 /************************************************************************/
923 /* GetLayerDefn() */
924 /************************************************************************/
925
926 const OGRFeatureDefn *OGRHanaLayer::GetLayerDefn() const
927 {
928 const_cast<OGRHanaLayer *>(this)->EnsureInitialized();
929 return featureDefn_;
930 }
931
932 /************************************************************************/
933 /* GetName() */
934 /************************************************************************/
935
936 const char *OGRHanaLayer::GetName() const
937 {
938 return GetDescription();
939 }
940
941 /************************************************************************/
942 /* GetNextFeature() */
943 /************************************************************************/
944
945 OGRFeature *OGRHanaLayer::GetNextFeature()
946 {
947 EnsureInitialized();
948
949 while (true)
950 {
951 OGRFeature *feature = GetNextFeatureInternal();
952 if (feature == nullptr)
953 return nullptr;
954
955 if ((m_poFilterGeom == nullptr ||
956 FilterGeometry(feature->GetGeometryRef())) &&
957 (m_poAttrQuery == nullptr || m_poAttrQuery->Evaluate(feature)))
958 return feature;
959
960 delete feature;
961 }
962 }
963
964 /************************************************************************/
965 /* GetFIDColumn() */
966 /************************************************************************/
967
968 const char *OGRHanaLayer::GetFIDColumn() const
969 {
970 const_cast<OGRHanaLayer *>(this)->EnsureInitialized();
971 return fidFieldName_.c_str();
972 }
973
974 /************************************************************************/
975 /* SetAttributeFilter() */
976 /************************************************************************/
977
978 OGRErr OGRHanaLayer::SetAttributeFilter(const char *pszQuery)
979 {
980 CPLFree(m_pszAttrQueryString);
981 m_pszAttrQueryString = pszQuery ? CPLStrdup(pszQuery) : nullptr;
982
983 if (pszQuery == nullptr || strlen(pszQuery) == 0)
984 attrFilter_ = "";
985 else
986 attrFilter_.assign(pszQuery, strlen(pszQuery));
987
988 ClearQueryStatement();
989 BuildWhereClause();
990 ResetReading();
991
992 return OGRERR_NONE;
993 }
994
995 /************************************************************************/
996 /* ISetSpatialFilter() */
997 /************************************************************************/
998
999 OGRErr OGRHanaLayer::ISetSpatialFilter(int iGeomField,
1000 const OGRGeometry *poGeom)
1001 {
1002 m_iGeomFieldFilter = iGeomField;
1003
1004 if (!InstallFilter(poGeom))
1005 return OGRERR_NONE;
1006
1007 ClearQueryStatement();
1008 BuildWhereClause();
1009 ResetReading();
1010 return OGRERR_NONE;
1011 }
1012
1013 } // namespace OGRHANA