ConnectedDataSet.cpp

Go to the documentation of this file.

/*  Copyright (C) 2008 National Institute For Space Research (INPE) - Brazil.

    This file is part of the TerraLib - a Framework for building GIS enabled applications.

    TerraLib is free software: you can redistribute it and/or modify
    it under the terms of the GNU Lesser General Public License as published by
    the Free Software Foundation, either version 3 of the License,
    or (at your option) any later version.

    TerraLib is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
    GNU Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public License
    along with TerraLib. See COPYING. If not, write to
    TerraLib Team at <terralib-team@terralib.org>.
 */

/*!
  \file terralib/postgis/ConnectedDataSet.cpp

  \brief Implementation of a connected dataset for the PostGIS driver.
*/

// TerraLib
#include "../Defines.h"
#include "../common/ByteSwapUtils.h"
#include "../common/Globals.h"
#include "../common/StringUtils.h"
#include "../core/translator/Translator.h"
#include "../dataaccess/dataset/DataSetType.h"
#include "../datatype/Array.h"
#include "../datatype/ByteArray.h"
#include "../datatype/DateTime.h"
#include "../datatype/SimpleData.h"
#include "../geometry/Geometry.h"
#include "Connection.h"
#include "ConnectionPool.h"
#include "ConnectedDataSet.h"
#include "DataSource.h"
#include "EWKBReader.h"
#include "Exception.h"
#include "ScopedConnection.h"
#include "Utils.h"

// STL
#include <cassert>
#include <memory>

// Boost
#include <boost/dynamic_bitset.hpp>

// libpq
#include <libpq-fe.h>

namespace te
{
  namespace pgis
  {
    /*!
      \brief It retrieves information from an unidimensional array.

      Requirements on types:
      <ul>
      <li>T: the type of basic elements of the array.</li>
      <li>ALIGN: the size in bytes of pointer alignment for the type T.</li>
      </ul>

      \param i      The row.
      \param j      The column.
      \param result The result to extract the array.
      \param a      The output vector.

      \warning Don't call this method for multidimensional arrays!
     */
    template<class T, class ALIGN> inline void GetArray(int i, int j, PGresult* result, std::vector<T>& a)
    {
      char* value = PQgetvalue(result, i, j);

      int ndim = *(reinterpret_cast<int*>(value));
      value += sizeof(int);

      int dataoffset = *(reinterpret_cast<int*>(value));
      value += sizeof(int);

      unsigned int elemtype = *(reinterpret_cast<unsigned int*>(value));
      value += sizeof(unsigned int);

      int dimension = *(reinterpret_cast<int*>(value));
      value += sizeof(int);

      int lowerbnds = *(reinterpret_cast<int*>(value));
      value += (2 * sizeof(int)); //jump null-bitmap field

      if(te::common::Globals::sm_machineByteOrder == TE_NDR)
      {
        te::common::SwapBytes(ndim);
        te::common::SwapBytes(dataoffset);
        te::common::SwapBytes(elemtype);
        te::common::SwapBytes(dimension);
        te::common::SwapBytes(lowerbnds);

        a.reserve(static_cast<size_t>(dimension));

        for(int k = 0; k < dimension; ++k)
        {
          T v = *(reinterpret_cast<T*>(value));
          te::common::SwapBytes(v);
          a.push_back(v);
          value += sizeof(ALIGN);
        }
      }
      else
      {
        a.reserve(static_cast<size_t>(dimension));

        for(int k = 0; k < dimension; ++k)
        {
          T v = *(reinterpret_cast<T*>(value));
          a.push_back(v);
          value += sizeof(ALIGN);
        }
      }
    }

  } // end namespace pgis
}   // end namespace te

te::pgis::ConnectedDataSet::ConnectedDataSet(PGresult* result,
                                             DataSource* dataSource,
                                             const int& connectionId,
                                             const std::string& id_cursor,
                                             const int& size,
                                             const std::vector<int>& ptypes,
                                             bool timeIsInteger) :
    m_iFetch(-1),
    m_iLayer(-1),
    m_size(size),
    m_result(result),
    m_ds(dataSource),
    m_connectionId(connectionId),
    m_idcursor(id_cursor),
    m_ptypes(ptypes),
    m_mbr(nullptr),
    m_timeIsInteger(timeIsInteger)
{
  m_fetchSize = PQntuples(m_result);
}

te::pgis::ConnectedDataSet::~ConnectedDataSet()
{
  ScopedConnection scopedConnection(m_ds->getConnPool(), m_connectionId);

  scopedConnection->execute("CLOSE " + m_idcursor + ";");

  PQclear(m_result);
}

te::common::TraverseType te::pgis::ConnectedDataSet::getTraverseType() const
{
  return te::common::RANDOM;
}

te::common::AccessPolicy te::pgis::ConnectedDataSet::getAccessPolicy() const
{
  return te::common::RAccess;
}

std::size_t te::pgis::ConnectedDataSet::getNumProperties() const
{
  return static_cast<size_t>(PQnfields(m_result));
}

int te::pgis::ConnectedDataSet::getPropertyDataType(std::size_t i) const
{
  return m_ptypes[i];
}

std::string te::pgis::ConnectedDataSet::getPropertyName(std::size_t i) const
{
  return PQfname(m_result, static_cast<int>(i));
}

std::string te::pgis::ConnectedDataSet::getDatasetNameOfProperty(std::size_t/* i*/) const
{
  throw Exception(TE_TR("Not implemented yet!"));
}

bool te::pgis::ConnectedDataSet::isEmpty() const
{
  return (m_size == 0);
}

bool te::pgis::ConnectedDataSet::isConnected() const
{
  return true;
}

std::size_t te::pgis::ConnectedDataSet::size() const
{
  return static_cast<std::size_t>(m_size);
}

std::unique_ptr<te::gm::Envelope> te::pgis::ConnectedDataSet::getExtent(std::size_t i)
{
  if(!m_mbr)
  {
    if(m_ptypes[i] != te::dt::GEOMETRY_TYPE)
      throw Exception(TE_TR("This driver only supports the getExtent method over a geometry column!"));

    m_mbr = new te::gm::Envelope;

    m_iFetch = -1;
    while(moveNext())
    {
      std::unique_ptr<te::gm::Geometry> geom(getGeometry(i));
      m_mbr->Union(*(geom->getMBR()));
    }
  }

  m_iFetch = -1;

  te::gm::Envelope* mbr = new te::gm::Envelope(*m_mbr);

  return std::unique_ptr<te::gm::Envelope>(mbr);
}

bool te::pgis::ConnectedDataSet::moveNext()
{
  ScopedConnection scopedConnection(m_ds->getConnPool(), m_connectionId);

  ++m_iLayer;
  ++m_iFetch;

  if(m_iFetch >= m_fetchSize && m_iLayer < m_size)
  {
    std::string fetch("FETCH FORWARD ");
    fetch += boost::lexical_cast<std::string>(m_fetchSize);
    fetch += " FROM ";
    fetch += m_idcursor;

    m_iFetch = 0;

    PQclear(m_result);
    m_result = scopedConnection->query(fetch);
    m_fetchSize = PQntuples(m_result);

    if(m_fetchSize == 0)
      return false;
  }

  return m_iLayer < m_size;
}

bool te::pgis::ConnectedDataSet::movePrevious()
{
  ScopedConnection scopedConnection(m_ds->getConnPool(), m_connectionId);

  --m_iLayer;
  ++m_iFetch;

  if(m_iFetch >= m_fetchSize && m_iLayer > -1)
  {
    std::string fetch("FETCH BACKWARD ");
    fetch += boost::lexical_cast<std::string>(m_fetchSize);
    fetch += " FROM ";
    fetch += m_idcursor;

    m_iFetch = 0;

    PQclear(m_result);
    m_result = scopedConnection->query(fetch);
    m_fetchSize = PQntuples(m_result);

    if(m_fetchSize == 0)
      return false;
  }

  return (m_iLayer > -1);
}

bool te::pgis::ConnectedDataSet::moveFirst()
{
  // Gets the fetch first in -1 index.
  moveBeforeFirst();

  // Move the index to the first position.
  moveNext();

  return m_fetchSize != 0;
}

bool te::pgis::ConnectedDataSet::moveLast()
{
  ScopedConnection scopedConnection(m_ds->getConnPool(), m_connectionId);

  std::string fetch("FETCH LAST ");
  fetch += "FROM ";
  fetch += m_idcursor;

  PQclear(m_result);
  m_result = scopedConnection->query(fetch);
  m_fetchSize = PQntuples(m_result);

  m_iLayer = m_size - 1;
  m_iFetch = m_fetchSize - 1;

  return m_fetchSize != 0;
}

bool te::pgis::ConnectedDataSet::moveBeforeFirst()
{
  ScopedConnection scopedConnection(m_ds->getConnPool(), m_connectionId);

  std::string fetch("FETCH FIRST ");
  fetch += "FROM ";
  fetch += m_idcursor;

  m_iLayer = -1;
  m_iFetch = -1;

  PQclear(m_result);
  m_result = scopedConnection->query(fetch);
  m_fetchSize = PQntuples(m_result);

  return m_fetchSize != 0;
}

bool te::pgis::ConnectedDataSet::move(std::size_t i)
{
  if(static_cast<int>(i) >= m_size)
    return false;

  ScopedConnection scopedConnection(m_ds->getConnPool(), m_connectionId);

  std::string fetchRelative("FETCH ABSOLUTE ");
  fetchRelative += boost::lexical_cast<std::string>(i+1);
  fetchRelative += " FROM ";
  fetchRelative += m_idcursor;

  PQclear(m_result);
  m_result = scopedConnection->query(fetchRelative);
  m_fetchSize = PQntuples(m_result);

  m_iLayer = static_cast<int>(i);
  m_iFetch = m_fetchSize - 1;

  return (m_iLayer < m_size);
}

bool te::pgis::ConnectedDataSet::isAtBegin() const
{
  return m_iLayer == 0;
}

bool te::pgis::ConnectedDataSet::isBeforeBegin() const
{
  return m_iLayer < 0;
}

bool te::pgis::ConnectedDataSet::isAtEnd() const
{
  return m_iLayer == (m_size - 1);
}

bool te::pgis::ConnectedDataSet::isAfterEnd() const
{
  return m_iLayer >= m_size;
}

bool te::pgis::ConnectedDataSet::isPositionValid() const
{
  return m_iLayer > -1 && m_iLayer < m_size;
}

char te::pgis::ConnectedDataSet::getChar(std::size_t i) const
{
  char cval = *(PQgetvalue(m_result, m_iFetch, static_cast<int>(i)));
  return cval;
}

unsigned char te::pgis::ConnectedDataSet::getUChar(std::size_t i) const
{
  unsigned char cval = *reinterpret_cast<unsigned char*>((PQgetvalue(m_result, m_iFetch, static_cast<int>(i))));
  return cval;
}

boost::int16_t te::pgis::ConnectedDataSet::getInt16(std::size_t i) const
{
  short int ival = *(reinterpret_cast<short int*>(PQgetvalue(m_result, m_iFetch, static_cast<int>(i))));

#if TE_MACHINE_BYTE_ORDER == TE_NDR
  te::common::SwapBytes(ival);
#endif

  return static_cast<boost::int16_t>(ival);
}

boost::int32_t te::pgis::ConnectedDataSet::getInt32(std::size_t i) const
{
  int ival = *(reinterpret_cast<int*>(PQgetvalue(m_result, m_iFetch, static_cast<int>(i))));

#if TE_MACHINE_BYTE_ORDER == TE_NDR
  te::common::SwapBytes(ival);
#endif

  return static_cast<boost::int32_t>(ival);
}

boost::int64_t te::pgis::ConnectedDataSet::getInt64(std::size_t i) const
{
  boost::int64_t ival = *(reinterpret_cast<boost::int64_t*>(PQgetvalue(m_result, m_iFetch, static_cast<int>(i))));

#if TE_MACHINE_BYTE_ORDER == TE_NDR
  te::common::SwapBytes(ival);
#endif

  return ival;
}

bool te::pgis::ConnectedDataSet::getBool(std::size_t i) const
{
  char bval = *(PQgetvalue(m_result, m_iFetch, static_cast<int>(i)));
  return bval != 0;
}

float te::pgis::ConnectedDataSet::getFloat(std::size_t i) const
{
  float fval = *(reinterpret_cast<float*>(PQgetvalue(m_result, m_iFetch, static_cast<int>(i))));

#if TE_MACHINE_BYTE_ORDER == TE_NDR
  te::common::SwapBytes(fval);
#endif

  return fval;
}

double te::pgis::ConnectedDataSet::getDouble(std::size_t i) const
{
  double dval = *(reinterpret_cast<double*>(PQgetvalue(m_result, m_iFetch, static_cast<int>(i))));

#if TE_MACHINE_BYTE_ORDER == TE_NDR
  te::common::SwapBytes(dval);
#endif

  return dval;
}

std::string te::pgis::ConnectedDataSet::getNumeric(std::size_t i) const
{
  char* val = PQgetvalue(m_result, m_iFetch, static_cast<int>(i));

// get number of groups of 2 bytes used to represent the numeric number
// each 2 bytes represents 4 digits (ex: 2345678.87654 needs 4 groups. 2 to integer and 2 to decimals)
  unsigned short totalGroups; // total number of groups

  totalGroups = *(reinterpret_cast<unsigned short*>(val));

#if TE_MACHINE_BYTE_ORDER == TE_NDR
  te::common::SwapBytes(totalGroups);
#endif

  if(totalGroups == 0)
    return "0";

// get number of groups of 2 bytes used to represent the decimal part of the number
  unsigned short decimalGroups; // total number of groups

  decimalGroups = *(reinterpret_cast<unsigned short*>(val+2));

#if TE_MACHINE_BYTE_ORDER == TE_NDR
  te::common::SwapBytes(decimalGroups);
#endif

  ++decimalGroups;

  decimalGroups = totalGroups - decimalGroups;

// get sign of the number
  unsigned short sign; // sign of the number (positive: sign = 0, negative: sign = 0x4000)

  sign = *(reinterpret_cast<unsigned short*>(val+4));

#if TE_MACHINE_BYTE_ORDER == TE_NDR
    te::common::SwapBytes(sign);
#endif

  if(!(sign == 0 || sign == 0x4000))
    return "";

  std::string intVal;

  if(sign != 0)
    intVal = "-";

//get integer part
  unsigned short n;

  unsigned short ii = 0;

  while(ii < ((totalGroups - decimalGroups) * 2))
  {
    n = *(reinterpret_cast<unsigned short*>(val + ii + 8));

#if TE_MACHINE_BYTE_ORDER == TE_NDR
    te::common::SwapBytes(n);
#endif

    std::string v = te::common::Convert2String(static_cast<uint32_t>(n));
    if(intVal.empty() == false)
    {
      if(n < 10)
        v = "000" + v;
      else if(n < 100)
        v = "00" + v;
      else if(n < 1000)
        v = "0" + v;
    }

    intVal += v;
    ii += 2;
  }

  if(ii == 0)
    intVal += "0";

//get decimal part
  std::string decVal;

  if(decimalGroups == 0)
    decVal = "0";
  else
  {
    while(ii < (totalGroups * 2))
    {
      n = *(reinterpret_cast<unsigned short*>(val + ii + 8));

#if TE_MACHINE_BYTE_ORDER == TE_NDR
      te::common::SwapBytes(n);
#endif

      std::string newVal = te::common::Convert2String(static_cast<uint32_t>(n));

      while (newVal.length() < 4) //fill with zeros (ex: .0700 was "700")
        newVal = "0" + newVal;

      decVal += newVal;

      ii += 2;
    }

    while(!(decVal.empty()) && (decVal[decVal.length() - 1] == '0'))
      decVal.erase(decVal.length() - 1);
  }

  return intVal + "." + decVal;
}

std::string te::pgis::ConnectedDataSet::getString(std::size_t i) const
{
  std::string value(PQgetvalue(m_result, m_iFetch, static_cast<int>(i)));
  return value;
}

std::unique_ptr<te::dt::ByteArray> te::pgis::ConnectedDataSet::getByteArray(std::size_t i) const
{
  int size = PQgetlength(m_result, m_iFetch, static_cast<int>(i));

  te::dt::ByteArray* b = new te::dt::ByteArray(static_cast<size_t>(size));
  b->copy(PQgetvalue(m_result, m_iFetch, static_cast<int>(i)), static_cast<size_t>(size));
  return std::unique_ptr<te::dt::ByteArray>(b);
}

std::unique_ptr<te::gm::Geometry> te::pgis::ConnectedDataSet::getGeometry(std::size_t i) const
{
  return std::unique_ptr<te::gm::Geometry>(EWKBReader::read(PQgetvalue(m_result, m_iFetch, static_cast<int>(i))));
}

std::unique_ptr<te::rst::Raster> te::pgis::ConnectedDataSet::getRaster(std::size_t /*i*/) const
{
  return std::unique_ptr<te::rst::Raster>();
}

std::unique_ptr<te::dt::DateTime> te::pgis::ConnectedDataSet::getDateTime(std::size_t i) const
{
  Oid tid = PQftype(m_result, static_cast<int>(i));
  boost::int64_t ival = 0;
  int iz;
  double dval;

  switch(tid)
  {
    case PG_TIME_TYPE:
      {
        if(m_timeIsInteger)
        {
          ival = getInt64(i);
        }
        else
        {
          dval = getDouble(i);
          ival = static_cast<boost::int64_t>(dval * 1000000);
        }

        return std::unique_ptr<te::dt::DateTime>(Internal2Time(ival));
      }

    case PG_DATE_TYPE:
      {
        ival = static_cast<boost::int64_t>(getInt32(i));

        return std::unique_ptr<te::dt::DateTime>(Internal2Date(static_cast<long>(ival)));
      }

    case PG_TIMESTAMP_TYPE:
      {
        if(m_timeIsInteger)
          ival = getInt64(i);
        else
        {
          dval = getDouble(i);
          ival = static_cast<boost::int64_t>(dval * 1000000);
        }
    
        return std::unique_ptr<te::dt::DateTime>(Internal2TimeStamp(ival)); 
      }

    case PG_TIMESTAMPTZ_TYPE:
      {
        if(m_timeIsInteger)
        {
          ival = getInt64(i);
          iz = 0;
        }
        else
        {
          char* c = static_cast<char*>(PQgetvalue(m_result, m_iFetch, static_cast<int>(i)));
          dval = *(reinterpret_cast<double*>(c));
          c += 8;
          iz = *(reinterpret_cast<int*>(c));

          #if TE_MACHINE_BYTE_ORDER == TE_NDR
            te::common::SwapBytes(dval);
            te::common::SwapBytes(iz);
          #endif

          ival = static_cast<boost::int64_t>(dval * 1000000);
        }
        iz /= 3600;
        if(iz < -12)
          iz = -12;
        if(iz > 14)
          iz = 14;

        return std::unique_ptr<te::dt::DateTime>(Internal2TimeStampTZ(ival, iz));
      }
    case PG_TIMETZ_TYPE:
      {
        if(m_timeIsInteger)
        {
          ival = getInt64(i);
          iz = 0;
        }
        else
        {
          char* c = static_cast<char*>(PQgetvalue(m_result, m_iFetch, static_cast<int>(i)));
          dval = *(reinterpret_cast<double*>(c));
          c += 8;
          iz = *(reinterpret_cast<int*>(c));

          #if TE_MACHINE_BYTE_ORDER == TE_NDR
            te::common::SwapBytes(dval);
            te::common::SwapBytes(iz);
          #endif

          ival = static_cast<boost::int64_t>(dval * 1000000);
        }
        iz /= 3600;
        if(iz < -12)
          iz = -12;
        if(iz > 14)
          iz = 14;
        return std::unique_ptr<te::dt::DateTime>(Internal2TimeTZ(ival, iz));
      }

    default:
      throw Exception(TE_TR("This type is not supported by TerraLib!"));
  }
}

std::unique_ptr<te::dt::Array> te::pgis::ConnectedDataSet::getArray(std::size_t i) const
{
  char* value = PQgetvalue(m_result, m_iFetch, static_cast<int>(i));

  int ndim = *(reinterpret_cast<int*>(value));
  value += sizeof(int);

#if TE_MACHINE_BYTE_ORDER == TE_NDR
  te::common::SwapBytes(ndim);
#endif

  int dataoffset = *(reinterpret_cast<int*>(value));
  value += sizeof(int);

#if TE_MACHINE_BYTE_ORDER == TE_NDR
  te::common::SwapBytes(dataoffset);
#endif

  unsigned int elemtype = *(reinterpret_cast<unsigned int*>(value));
  value += sizeof(unsigned int);

#if TE_MACHINE_BYTE_ORDER == TE_NDR
  te::common::SwapBytes(elemtype);
#endif

  int* dimensions = reinterpret_cast<int*>(value);
  value += ndim * sizeof(int);

  int* lowerbounds = reinterpret_cast<int*>(value);
  value += ndim * sizeof(int);

  uint32_t* null_bitmap = reinterpret_cast<uint32_t*>(value);

  boost::dynamic_bitset<size_t> mask;

  if(dataoffset != 0)
  {
    int nmasks = (dataoffset + 3) / 4;

    mask.resize(static_cast<size_t>(nmasks * 8 * sizeof(uint32_t)));

    int pos = 0;

    for(int i = 0; i != nmasks; ++i)
    {
      value += sizeof(uint32_t);

      uint32_t umask = null_bitmap[i];

#if TE_MACHINE_BYTE_ORDER == TE_NDR
      te::common::SwapBytes(umask);
#endif

      for(int j = 0; j != 32; ++j)
      {
        mask[pos] = static_cast<unsigned long>(((umask >> j) & 1) == 0);
        ++pos;
      }
    }
  }
  else
  {
    value += sizeof(uint32_t);
  }

  switch(elemtype)
  {
    case PG_TEXT_TYPE:
    case PG_VARCHAR_TYPE:
    case PG_NAME_TYPE:
      {
        std::unique_ptr<te::dt::Array> arr(new te::dt::Array(static_cast<size_t>(ndim), te::dt::STRING_TYPE));

        std::vector<std::size_t> pos(static_cast<size_t>(ndim), 0);

        for(int d = 0; d != ndim; ++d)
        {
          int d_size = dimensions[d];

#if TE_MACHINE_BYTE_ORDER == TE_NDR
          te::common::SwapBytes(d_size);
#endif
          int d_lower_boundary = lowerbounds[d];

#if TE_MACHINE_BYTE_ORDER == TE_NDR
          te::common::SwapBytes(d_lower_boundary);
#endif

          for(i = 0; i != static_cast<size_t>(d_size); ++i)
          {
            if((dataoffset != 0) && (!mask[i]))
            {
              arr->insert(nullptr, pos);
              continue;
            }

            pos[d] = i;

            int text_size = *reinterpret_cast<int*>(value);

#if TE_MACHINE_BYTE_ORDER == TE_NDR
            te::common::SwapBytes(text_size);
#endif
            value += sizeof(int);

            arr->insert(new te::dt::String(value), pos);

            value += text_size;
          }
        }

        return std::unique_ptr<te::dt::Array>(arr.release());
      }

    case PG_FLOAT8_TYPE:
      {
        std::unique_ptr<te::dt::Array> arr(new te::dt::Array(static_cast<size_t>(ndim), te::dt::DOUBLE_TYPE));

        std::vector<std::size_t> pos(static_cast<size_t>(ndim), 0);

        for(int d = 0; d != ndim; ++d)
        {
          int d_size = dimensions[d];

#if TE_MACHINE_BYTE_ORDER == TE_NDR
          te::common::SwapBytes(d_size);
#endif
          int d_lower_boundary = lowerbounds[d];

#if TE_MACHINE_BYTE_ORDER == TE_NDR
          te::common::SwapBytes(d_lower_boundary);
#endif

          for(i = 0; i != static_cast<size_t>(d_size); ++i)
          {
            if((dataoffset != 0) && (!mask[i]))
            {
              arr->insert(nullptr, pos);
              continue;
            }

            pos[d] = i;

            double val = *reinterpret_cast<double*>(value);

#if TE_MACHINE_BYTE_ORDER == TE_NDR
            te::common::SwapBytes(val);
#endif

            arr->insert(new te::dt::Double(val), pos);

            value += sizeof(double);
          }
        }

        return std::unique_ptr<te::dt::Array>(arr.release());
      }

    case PG_INT2_TYPE:
      {
        std::unique_ptr<te::dt::Array> arr(new te::dt::Array(static_cast<size_t>(ndim), te::dt::INT16_TYPE));

        std::vector<std::size_t> pos(static_cast<size_t>(ndim), 0);

        for(int d = 0; d != ndim; ++d)
        {
          int d_size = dimensions[d];

#if TE_MACHINE_BYTE_ORDER == TE_NDR
          te::common::SwapBytes(d_size);
#endif
          int d_lower_boundary = lowerbounds[d];

#if TE_MACHINE_BYTE_ORDER == TE_NDR
          te::common::SwapBytes(d_lower_boundary);
#endif

          for(i = 0; i != static_cast<size_t>(d_size); ++i)
          {
            if((dataoffset != 0) && (!mask[i]))
            {
              arr->insert(nullptr, pos);
              continue;
            }

            pos[d] = i;

            boost::uint16_t val = *reinterpret_cast<boost::uint16_t*>(value);

#if TE_MACHINE_BYTE_ORDER == TE_NDR
            te::common::SwapBytes(val);
#endif

            arr->insert(new te::dt::Int16(static_cast<int16_t>(val)), pos);

            value += sizeof(uint16_t);
          }
        }

        return std::unique_ptr<te::dt::Array>(arr.release());
      }

    default:
      throw Exception(TE_TR("The array element type is not supported yet!"));
  }

  //    {
  //      te::common::SwapBytes(ndim);
  //      te::common::SwapBytes(dataoffset);
  //      te::common::SwapBytes(elemtype);
  //      te::common::SwapBytes(dimension);
  //      te::common::SwapBytes(lowerbnds);

  //      a.reserve(dimension);

  //      for(int k = 0; k < dimension; ++k)
  //      {
  //        T v = *((T*)value);
  //        te::common::SwapBytes(v);
  //        a.push_back(v);
  //        value += sizeof(ALIGN);
  //      }
  //    }
  //    else
  //    {
  //      a.reserve(dimension);

  //      for(int k = 0; k < dimension; ++k)
  //      {
  //        T v = *((T*)value);
  //        a.push_back(v);
  //        value += sizeof(ALIGN);
  //      }
  //    }
}

bool te::pgis::ConnectedDataSet::isNull(std::size_t i) const
{
  return PQgetisnull(m_result, m_iFetch, static_cast<int>(i)) == 1;
}