reportbuilder/java/org/libreoffice/report/SDBCReportData.java

   1 /*
   2  * This file is part of the LibreOffice project.
   3  *
   4  * This Source Code Form is subject to the terms of the Mozilla Public
   5  * License, v. 2.0. If a copy of the MPL was not distributed with this
   6  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   7  *
   8  * This file incorporates work covered by the following license notice:
   9  *
  10  *   Licensed to the Apache Software Foundation (ASF) under one or more
  11  *   contributor license agreements. See the NOTICE file distributed
  12  *   with this work for additional information regarding copyright
  13  *   ownership. The ASF licenses this file to you under the Apache
  14  *   License, Version 2.0 (the "License"); you may not use this file
  15  *   except in compliance with the License. You may obtain a copy of
  16  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  17  */
  18 package org.libreoffice.report;
  19
  20 import com.sun.star.beans.UnknownPropertyException;
  21 import com.sun.star.beans.XPropertySet;
  22 import com.sun.star.container.XIndexAccess;
  23 import com.sun.star.container.XNameAccess;
  24 import com.sun.star.lang.IndexOutOfBoundsException;
  25 import com.sun.star.lang.WrappedTargetException;
  26 import com.sun.star.sdb.XParametersSupplier;
  27 import com.sun.star.sdbc.DataType;
  28 import com.sun.star.sdbc.SQLException;
  29 import com.sun.star.sdbc.XResultSetMetaData;
  30 import com.sun.star.sdbc.XResultSetMetaDataSupplier;
  31 import com.sun.star.sdbc.XRow;
  32 import com.sun.star.sdbc.XRowSet;
  33 import com.sun.star.sdbcx.XColumnsSupplier;
  34 import com.sun.star.uno.Any;
  35 import com.sun.star.uno.UnoRuntime;
  36 import com.sun.star.util.DateTime;
  37 import com.sun.star.util.Time;
  38
  39 import java.sql.Timestamp;
  40
  41 public class SDBCReportData implements DataSource
  42 {
  43
  44     private final XRowSet rowSet;
  45     private final XRow row;
  46     private int rowCount;
  47     private XIndexAccess parameters;
  48     private int firstParameterIndex = -1;
  49     private int columnCount;
  50     private final String[] columnNames;
  51     private final int[] columnTypes;
  52
  53     public SDBCReportData(final XRowSet rowSet) throws SQLException
  54     {
  55         row = UnoRuntime.queryInterface(XRow.class, rowSet);
  56         this.rowSet = rowSet;
  57
  58         if (rowSet == null)
  59         {
  60             rowCount = 0;
  61             columnCount = 0;
  62             columnTypes = new int[1];
  63             columnNames = new String[1];
  64         }
  65         else
  66         {
  67             final XParametersSupplier xSuppParams = UnoRuntime.queryInterface(
  68                     XParametersSupplier.class, rowSet);
  69             if (xSuppParams != null)
  70             {
  71                 parameters = xSuppParams.getParameters();
  72             }
  73
  74             final XColumnsSupplier columnsSup = UnoRuntime.queryInterface(XColumnsSupplier.class, rowSet);
  75             final XNameAccess columns = columnsSup.getColumns();
  76             final String[] columnNamesList = columns.getElementNames();
  77             final XResultSetMetaDataSupplier sup = UnoRuntime.queryInterface(XResultSetMetaDataSupplier.class, rowSet);
  78             final XResultSetMetaData resultSetMetaData = sup.getMetaData();
  79
  80             columnCount = resultSetMetaData.getColumnCount();
  81             firstParameterIndex = columnCount + 1;
  82             if (parameters != null)
  83             {
  84                 columnCount += parameters.getCount();
  85             }
  86
  87             columnTypes = new int[columnCount];
  88             columnNames = new String[columnCount];
  89
  90             for (int i = 1; i <= columnCount; ++i)
  91             {
  92                 if (i < firstParameterIndex)
  93                 {
  94                     columnNames[i - 1] = columnNamesList[i - 1];// resultSetMetaData.getColumnName(i);
  95                     columnTypes[i - 1] = resultSetMetaData.getColumnType(i);
  96                 }
  97                 else
  98                 {
  99                     try
 100                     {
 101                         final XPropertySet paramColumn = UnoRuntime.queryInterface(
 102                                 XPropertySet.class, parameters.getByIndex(i - firstParameterIndex));
 103                         columnNames[i - 1] = (String) paramColumn.getPropertyValue("Name");
 104                         columnTypes[i - 1] = (Integer) paramColumn.getPropertyValue("Type");
 105                     }
 106                     catch (Exception e)
 107                     {
 108                         columnNames[i - 1] = "Error";
 109                         columnTypes[i - 1] = DataType.CHAR;
 110                     }
 111                 }
 112             }
 113
 114             if (rowSet.last())
 115             {
 116                 rowCount = rowSet.getRow();
 117                 rowSet.beforeFirst();
 118             }
 119             else
 120             {
 121                 rowCount = 0;
 122             }
 123         }
 124     }
 125
 126     public int getColumnCount() throws DataSourceException
 127     {
 128         return columnCount;
 129     }
 130
 131     public int getRowCount()
 132     {
 133         return rowCount;
 134     }
 135
 136     public String getColumnName(final int column) throws DataSourceException
 137     {
 138         return columnNames[column - 1];
 139     }
 140
 141     public boolean absolute(final int row) throws DataSourceException
 142     {
 143         if (rowSet == null)
 144         {
 145             return false;
 146         }
 147         try
 148         {
 149             if (row == 0)
 150             {
 151                 rowSet.beforeFirst();
 152                 return true;
 153             }
 154             return rowSet.absolute(row);
 155         }
 156         catch (SQLException e)
 157         {
 158             throw new DataSourceException(e.getMessage(), e);
 159         }
 160     }
 161
 162     public boolean next() throws DataSourceException
 163     {
 164         if (rowSet == null)
 165         {
 166             return false;
 167         }
 168         try
 169         {
 170             return rowSet.next();
 171         }
 172         catch (SQLException e)
 173         {
 174             throw new DataSourceException(e.getMessage(), e);
 175         }
 176     }
 177
 178     public void close() throws DataSourceException
 179     {
 180     }
 181
 182     private static java.sql.Date getDate(final Object obj)
 183     {
 184         final java.sql.Date date;
 185         if (obj instanceof com.sun.star.util.Date)
 186         {
 187             final com.sun.star.util.Date unodate = (com.sun.star.util.Date) obj;
 188             date = java.sql.Date.valueOf(getDateString(unodate.Year, unodate.Month, unodate.Day).toString());
 189         }
 190         else
 191         {
 192             date = null;
 193         }
 194         return date;
 195     }
 196
 197     private static StringBuffer getTimeString(final int hours, final int minutes, final int seconds)
 198     {
 199         final StringBuffer timeString = new StringBuffer();
 200         if (hours < 10)
 201         {
 202             timeString.append('0');
 203         }
 204         timeString.append(hours);
 205         timeString.append(':');
 206         if (minutes < 10)
 207         {
 208             timeString.append('0');
 209         }
 210         timeString.append(minutes);
 211         timeString.append(':');
 212         if (seconds < 10)
 213         {
 214             timeString.append('0');
 215         }
 216         timeString.append(seconds);
 217         return timeString;
 218     }
 219
 220     private static StringBuffer getDateString(final int years, final int months, final int days)
 221     {
 222         final StringBuffer str = new StringBuffer();
 223         str.append(years);
 224         final StringBuffer str2 = new StringBuffer("0000");
 225         str2.delete(0, str.length());
 226         str.insert(0, str2);
 227         str.append('-');
 228         if (months < 10)
 229         {
 230             str.append('0');
 231         }
 232         str.append(months);
 233         str.append('-');
 234         if (days < 10)
 235         {
 236             str.append('0');
 237         }
 238         str.append(days);
 239         return str;
 240     }
 241
 242     private static java.sql.Time getTime(final Object obj)
 243     {
 244         final java.sql.Time time;
 245         if (obj instanceof Time)
 246         {
 247             final Time unoTime = (Time) obj;
 248             time = java.sql.Time.valueOf(getTimeString(unoTime.Hours, unoTime.Minutes, unoTime.Seconds).toString());
 249         }
 250         else
 251         {
 252             time = null;
 253         }
 254         return time;
 255     }
 256
 257     private static Timestamp getTimestamp(final Object obj)
 258     {
 259         final Timestamp ts;
 260         if (obj instanceof DateTime)
 261         {
 262             final DateTime unoTs = (DateTime) obj;
 263             final StringBuffer str = getDateString(unoTs.Year, unoTs.Month, unoTs.Day);
 264             str.append(' ');
 265             str.append(getTimeString(unoTs.Hours, unoTs.Minutes, unoTs.Seconds));
 266             str.append('.');
 267             str.append(String.format("%09d", unoTs.NanoSeconds));
 268             ts = java.sql.Timestamp.valueOf(str.toString());
 269         }
 270         else
 271         {
 272             ts = null;
 273         }
 274         return ts;
 275     }
 276
 277     public Object getObject(final int column) throws DataSourceException
 278     {
 279         if (rowSet == null)
 280         {
 281             return null;
 282         }
 283         try
 284         {
 285             final boolean isParameterValue = (parameters != null) && (column >= firstParameterIndex);
 286             Object obj;
 287             final boolean wasNull;
 288             if (isParameterValue)
 289             {
 290                 final XPropertySet paramCol = UnoRuntime.queryInterface(
 291                         XPropertySet.class, parameters.getByIndex(column - firstParameterIndex));
 292                 obj = paramCol.getPropertyValue("Value");
 293                 wasNull = obj == null;
 294             }
 295             else
 296             {
 297                 obj = row.getObject(column, null);
 298                 wasNull = row.wasNull();
 299             }
 300
 301             if (wasNull)
 302             {
 303                 obj = null;
 304             }
 305             else
 306             {
 307                 obj = convertObject(columnTypes[column - 1], obj);
 308             }
 309             return obj;
 310         }
 311         catch (SQLException ex)
 312         {
 313             throw new DataSourceException(ex.getMessage(), ex);
 314         }
 315         catch (UnknownPropertyException ex)
 316         {
 317             throw new DataSourceException(ex.getMessage(), ex);
 318         }
 319         catch (IndexOutOfBoundsException ex)
 320         {
 321             throw new DataSourceException(ex.getMessage(), ex);
 322         }
 323         catch (WrappedTargetException ex)
 324         {
 325             throw new DataSourceException(ex.getMessage(), ex);
 326         }
 327     }
 328
 329     private Object convertObject(final int type, final Object obj)
 330     {
 331         Object ret;
 332         switch (type)
 333         {
 334             case DataType.DATE:
 335                 ret = getDate(obj);
 336                 break;
 337             case DataType.TIME:
 338                 ret = getTime(obj);
 339                 break;
 340             case DataType.TIMESTAMP:
 341                 ret = getTimestamp(obj);
 342                 break;
 343             case DataType.DECIMAL:
 344             case DataType.NUMERIC:
 345                 if (!(obj instanceof Any))
 346                 {
 347                     try
 348                     {
 349                         ret = new java.math.BigDecimal(String.valueOf(obj));
 350                     }
 351                     catch (NumberFormatException ex)
 352                     {
 353                         ret = obj;
 354                     }
 355                 }
 356                 else
 357                 {
 358                     ret = obj;
 359                 }
 360                 break;
 361             default:
 362                 ret = obj;
 363                 break;
 364         }
 365         return ret;
 366     }
 367 }