How to use

ShardingException

in

io.shardingsphere.core.exception

private boolean isConnectToProxy(final DataSource[] dataSources) {
  for (DataSource each : dataSources) {
    try (Connection connection = each.getConnection()) {
      DatabaseMetaData databaseMetaData = connection.getMetaData();
      if (databaseMetaData.getDatabaseProductVersion().contains(PROXY_TAG)) {
        return true;
      }
    } catch (SQLException ex) {
      throw new ShardingException("Get databaseMetaData failed: ", ex);
    }
  }
  return false;
}

private void init() {
  try {
    underlyingTransactionManager.init();
  } catch (SystemException ex) {
    throw new ShardingException(ex);
  }
}

  private static Object convertDateValue(final Object value, final Class<?> convertType) {
    Date date = (Date) value;
    switch (convertType.getName()) {
      case "java.sql.Date":
        return new java.sql.Date(date.getTime());
      case "java.sql.Time":
        return new Time(date.getTime());
      case "java.sql.Timestamp":
        return new Timestamp(date.getTime());
      default:
        throw new ShardingException("Unsupported Date type:%s", convertType);
    }
  }
}

@Override
public void begin(final XATransactionContext transactionContext) throws ShardingException {
  try {
    underlyingTransactionManager.begin();
  } catch (final SystemException | NotSupportedException ex) {
    throw new ShardingException(ex);
  }
}

@Override
public void commit(final XATransactionContext transactionContext) throws ShardingException {
  try {
    underlyingTransactionManager.commit();
  } catch (final RollbackException | HeuristicMixedException | HeuristicRollbackException | SystemException ex) {
    throw new ShardingException(ex);
  }
}

/**
 * Initialize sharding tracer.
 */
public static void init() {
  String tracerClassName = System.getProperty(OPENTRACING_TRACER_CLASS_NAME);
  Preconditions.checkNotNull(tracerClassName, "Can not find opentracing tracer implementation class via system property `%s`", OPENTRACING_TRACER_CLASS_NAME);
  try {
    init((Tracer) Class.forName(tracerClassName).newInstance());
  } catch (final ReflectiveOperationException ex) {
    throw new ShardingException("Initialize opentracing tracer class failure.", ex);
  }
}

@Override
public int getStatus() throws ShardingException {
  try {
    return underlyingTransactionManager.getStatus();
  } catch (final SystemException ex) {
    throw new ShardingException(ex);
  }
}

private XATransactionManager load() {
  try {
    if (xaTransactionManagers.size() > 1) {
      log.warn("There are more than one transaction mangers existing, chosen first one by default.");
    }
    if (xaTransactionManagers.isEmpty()) {
      return new AtomikosTransactionManager();
    }
    return xaTransactionManagers.iterator().next();
  } catch (final Exception ex) {
    throw new ShardingException("Can not initialize the xaTransaction manager failed with " + ex);
  }
}

  /**
   * Create XA DataSource instance.
   *
   * @param databaseType database type
   * @return XA DataSource instance
   */
  public static XADataSource build(final DatabaseType databaseType) {
    String xaDataSourceClassName = XA_DRIVER_CLASS_NAMES.get(databaseType);
    Class xaDataSourceClass;
    try {
      xaDataSourceClass = Thread.currentThread().getContextClassLoader().loadClass(xaDataSourceClassName);
    } catch (final ClassNotFoundException ignored) {
      try {
        xaDataSourceClass = Class.forName(xaDataSourceClassName);
      } catch (final ClassNotFoundException ex) {
        throw new ShardingException("Failed to load [%s]", xaDataSourceClassName);
      }
    }
    try {
      return (XADataSource) xaDataSourceClass.newInstance();
    } catch (final InstantiationException | IllegalAccessException ex) {
      throw new ShardingException("Failed to instance [%s]", xaDataSourceClassName);
    }
  }
}

private void setTransactionManagerHandler(final PlatformTransactionManager transactionManager) {
  switch (TransactionManagerType.getTransactionManagerTypeByClassName(transactionManager.getClass().getName())) {
    case DATASOURCE:
      transactionManagerHandler = new DataSourceTransactionManagerHandler(transactionManager);
      break;
    case JPA:
      transactionManagerHandler = new JpaTransactionManagerHandler(transactionManager);
      break;
    case UNSUPPORTED:
    default:
      throw new ShardingException(String.format("Switching transaction Type is unsupported for transaction manager %s", transactionManager.getClass().getName()));
  }
}

@Override
public final void switchTransactionType(final TransactionType transactionType) {
  Connection connection = getConnectionFromTransactionManager();
  try (Statement statement = connection.createStatement()) {
    statement.execute(String.format(SET_TRANSACTION_TYPE_SQL, transactionType.name()));
  } catch (final SQLException ex) {
    throw new ShardingException("Switch transaction type for sharding-proxy failed: ", ex);
  }
}

private static Object convertNumberValue(final Object value, final Class<?> convertType) {
  Number number = (Number) value;
  switch (convertType.getName()) {
    case "byte":
      return number.byteValue();
    case "short":
      return number.shortValue();
    case "int":
      return number.intValue();
    case "long":
      return number.longValue();
    case "double":
      return number.doubleValue();
    case "float":
      return number.floatValue();
    case "java.math.BigDecimal":
      return new BigDecimal(number.toString());
    case "java.lang.Object":
      return value;
    case "java.lang.String":
      return value.toString();
    default:
      throw new ShardingException("Unsupported data type:%s", convertType);
  }
}

@Override
public void rollback(final XATransactionContext transactionContext) throws ShardingException {
  try {
    if (Status.STATUS_NO_TRANSACTION != getStatus()) {
      underlyingTransactionManager.rollback();
    }
  } catch (final SystemException ex) {
    throw new ShardingException(ex);
  }
}

@Override
public DataSource wrapDataSource(final DatabaseType databaseType, final XADataSource xaDataSource, final String dataSourceName, final DataSourceParameter dataSourceParameter) {
  try {
    return new AtomikosDataSourceBeanWrapper().wrap(databaseType, xaDataSource, dataSourceName, dataSourceParameter);
  } catch (final Exception ex) {
    throw new ShardingException("Failed to wrap XADataSource to transactional datasource pool", ex);
  }
}

  @Override
  protected Connection getConnectionFromTransactionManager() {
    try {
      Connection result = transactionManager.getDataSource().getConnection();
      TransactionSynchronizationManager.bindResource(transactionManager.getDataSource(), new ConnectionHolder(result));
      return result;
    } catch (final SQLException ex) {
      throw new ShardingException("Could not open JDBC Connection before transaction", ex);
    }
  }
}

static AbstractBeanDefinition getBeanDefinitionByElement(final Element element) {
  String type = element.getLocalName();
  switch (type) {
    case ShardingStrategyBeanDefinitionParserTag.STANDARD_STRATEGY_ROOT_TAG:
      return getStandardShardingStrategyConfigBeanDefinition(element);
    case ShardingStrategyBeanDefinitionParserTag.COMPLEX_STRATEGY_ROOT_TAG:
      return getComplexShardingStrategyConfigBeanDefinition(element);
    case ShardingStrategyBeanDefinitionParserTag.INLINE_STRATEGY_ROOT_TAG:
      return getInlineShardingStrategyConfigBeanDefinition(element);
    case ShardingStrategyBeanDefinitionParserTag.HINT_STRATEGY_ROOT_TAG:
      return getHintShardingStrategyConfigBeanDefinition(element);
    case ShardingStrategyBeanDefinitionParserTag.NONE_STRATEGY_ROOT_TAG:
      return getNoneShardingStrategyConfigBeanDefinition();
    default:
      throw new ShardingException("Cannot support type: %s", type);
  }
}