core/src/main/java/org/apache/calcite/avatica/DriverVersion.java

/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to you under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.apache.calcite.avatica;

import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;

/**
 * Driver version information.
 *
 * <p>Each driver implementation must provide an instance of this class, in
 * order to implement {@link UnregisteredDriver#createDriverVersion()}.</p>
 *
 * <p>There are two typical ways for a driver to instantiate its version
 * information:</p>
 *
 * <ul>
 *
 * <li>A driver might create a subclass in a with a constructor that provides
 * all of the arguments for the base class. The instance is held in a separate
 * file, so that that version information can be generated.</li>
 *
 * <li>A driver might store the version information in a .properties file and
 * load it using {@link #load}.</li>
 *
 * </ul>
 */
public class DriverVersion {
  public final int majorVersion;
  public final int minorVersion;
  public final String name;
  public final String versionString;
  public final String productName;
  public final String productVersion;
  public final boolean jdbcCompliant;
  public final int databaseMajorVersion;
  public final int databaseMinorVersion;

  /** Creates a DriverVersion. */
  public DriverVersion(
      String name,
      String versionString,
      String productName,
      String productVersion,
      boolean jdbcCompliant,
      int majorVersion,
      int minorVersion,
      int databaseMajorVersion,
      int databaseMinorVersion) {
    this.majorVersion = majorVersion;
    this.minorVersion = minorVersion;
    this.name = name;
    this.versionString = versionString;
    this.productName = productName;
    this.productVersion = productVersion;
    this.jdbcCompliant = jdbcCompliant;
    this.databaseMajorVersion = databaseMajorVersion;
    this.databaseMinorVersion = databaseMinorVersion;
  }

  /** Loads a driver version from a properties file, read from the classpath.
   * The arguments provide defaults if the properties cannot be loaded.
   *
   * @param driverClass Class of driver; used to find resource
   * @param resourceName Name of resource file
   * @param driverName Fallback name of driver
   * @param driverVersion Fallback version of driver
   * @param productName Fallback product name
   * @param productVersion Fallback product version
   * @return A populated driver version object, never null
   */
  public static DriverVersion load(
      Class<? extends UnregisteredDriver> driverClass,
      String resourceName,
      String driverName,
      String driverVersion,
      String productName,
      String productVersion) {
    boolean jdbcCompliant = true;
    int majorVersion = 0;
    int minorVersion = 0;
    int databaseMajorVersion = 0;
    int databaseMinorVersion = 0;
    try (final InputStream inStream =
          driverClass.getClassLoader().getResourceAsStream(resourceName)) {
      if (inStream != null) {
        final Properties properties = new Properties();
        properties.load(inStream);
        driverName = properties.getProperty("driver.name");
        driverVersion = properties.getProperty("driver.version");
        productName = properties.getProperty("product.name");
        productVersion = properties.getProperty("product.version");
        jdbcCompliant =
            Boolean.valueOf(properties.getProperty("jdbc.compliant"));
        String[] s = driverVersion.replaceAll("-.*$", "").split("\\.");
        final int major = Integer.parseInt(s[0]);
        final int minor = Integer.parseInt(s[1]);
        try {
          majorVersion =
              Integer.parseInt(properties.getProperty("driver.version.major"));
        } catch (NumberFormatException e) {
          majorVersion = major;
        }
        try {
          minorVersion =
              Integer.parseInt(properties.getProperty("driver.version.minor"));
        } catch (NumberFormatException e) {
          minorVersion = minor;
        }
        try {
          databaseMajorVersion =
              Integer.parseInt(properties.getProperty("database.version.major"));
        } catch (NumberFormatException e) {
          databaseMajorVersion = major;
        }
        try {
          databaseMinorVersion =
              Integer.parseInt(properties.getProperty("database.version.minor"));
        } catch (NumberFormatException e) {
          databaseMinorVersion = minor;
        }
      }
    } catch (IOException e) {
      e.printStackTrace();
    }
    return new DriverVersion(
        driverName, driverVersion, productName, productVersion,
        jdbcCompliant, majorVersion, minorVersion, databaseMajorVersion,
        databaseMinorVersion);
  }
}

// End DriverVersion.java