Java SQLDataException類代碼示例

import java.sql.SQLDataException; //導入依賴的package包/類
/**
 * @test java.sql.SQLDataException(String, String, int, Throwable)
 */
public void test_Constructor_LStringLStringILThrowable_20() {
    Throwable cause = new Exception("MYTHROWABLE");
    SQLDataException sQLDataException = new SQLDataException(null, null, 0,
            cause);
    assertNotNull(sQLDataException);
    assertNull("The SQLState of SQLDataException should be null",
            sQLDataException.getSQLState());
    assertNull("The reason of SQLDataException should be null",
            sQLDataException.getMessage());
    assertEquals("The error code of SQLDataException should be 0",
            sQLDataException.getErrorCode(), 0);
    assertEquals(
            "The cause of SQLDataException set and get should be equivalent",
            cause, sQLDataException.getCause());
}
 

import java.sql.SQLDataException; //導入依賴的package包/類
/**
 * Validate that the ordering of the returned Exceptions is correct
 * using traditional while loop
 */
@Test
public void test12() {
    SQLDataException ex = new SQLDataException("Exception 1", t1);
    SQLDataException ex1 = new SQLDataException("Exception 2");
    SQLDataException ex2 = new SQLDataException("Exception 3", t2);
    ex.setNextException(ex1);
    ex.setNextException(ex2);
    int num = 0;
    SQLException sqe = ex;
    while (sqe != null) {
        assertTrue(msgs[num++].equals(sqe.getMessage()));
        Throwable c = sqe.getCause();
        while (c != null) {
            assertTrue(msgs[num++].equals(c.getMessage()));
            c = c.getCause();
        }
        sqe = sqe.getNextException();
    }
}
 

import java.sql.SQLDataException; //導入依賴的package包/類
public void testGetBinaryStream(ResultSet resultSet) throws SQLException {
  try {
    resultSet.getBinaryStream(ordinal);
    fail("Was expecting to throw SQLDataException");
  } catch (Exception e) {
    assertThat(e, isA((Class) SQLDataException.class)); // success
  }
}
 

import java.sql.SQLDataException; //導入依賴的package包/類
public void testGetDate(ResultSet resultSet, Calendar calendar) throws SQLException {
  try {
    resultSet.getDate(ordinal, calendar);
    fail("Was expecting to throw SQLDataException");
  } catch (Exception e) {
    assertThat(e, isA((Class) SQLDataException.class)); // success
  }
}
 

import java.sql.SQLDataException; //導入依賴的package包/類
public void testGetNClob(ResultSet resultSet) throws SQLException {
  try {
    resultSet.getNClob(ordinal);
    fail("Was expecting to throw SQLDataException");
  } catch (Exception e) {
    assertThat(e, isA((Class) SQLDataException.class)); // success
  }
}
 

import java.sql.SQLDataException; //導入依賴的package包/類
/**
 * Type modifier input function for IntWithMod type: accepts
 * "even" or "odd". The modifier value is 0 for even or 1 for odd.
 */
@Function(schema="javatest", name="intwithmod_typmodin",
	provides="IntWithMod modIn",
	effects=IMMUTABLE, onNullInput=RETURNS_NULL)
public static int modIn(@SQLType("cstring[]") String[] toks)
	throws SQLException {
	if ( 1 != toks.length )
		throw new SQLDataException(
			"only one type modifier allowed for IntWithMod", "22023");
	if ( "even".equalsIgnoreCase(toks[0]) )
		return 0;
	if ( "odd".equalsIgnoreCase(toks[0]) )
		return 1;
	throw new SQLDataException(
		"modifier for IntWithMod must be \"even\" or \"odd\"", "22023");
}
 

import java.sql.SQLDataException; //導入依賴的package包/類
/**
 * Function backing the type-modifier application cast for IntWithMod type.
 */
@Function(schema="javatest", name="intwithmod_typmodapply",
	requires="IntWithMod type", provides="IntWithMod modApply",
	type="javatest.IntWithMod", effects=IMMUTABLE, onNullInput=RETURNS_NULL)
public static IntWithMod modApply(
	@SQLType("javatest.IntWithMod") IntWithMod iwm,
	int mod, boolean explicit) throws SQLException {

	if ( -1 == mod )
		return iwm;
	if ( (iwm.m_value & 1) != mod )
		throw new SQLDataException(
			"invalid value " + iwm + " for " +
			iwm.getSQLTypeName() + modOut(mod), "22000");
	iwm.m_typeName += modOut(mod);
	return iwm;
}
 

import java.sql.SQLDataException; //導入依賴的package包/類
private static String validateDateTime(Object value, boolean timestampTz) throws SQLDataException {
    if (value instanceof Number) {
        return AtsdMeta.TIMESTAMP_PRINTER.format(((Number) value).longValue());
    } else if (!(value instanceof String)) {
        throw new SQLDataException("Invalid value: " + value + ". Current type: " + value.getClass().getSimpleName()
                + ", expected type: " + Timestamp.class.getSimpleName());
    }
    final String dateTime = value.toString();
    Matcher matcher = DATETIME_ISO_PATTERN.matcher(dateTime);
    if (matcher.matches()) {
        return dateTime;
    }
    matcher = TIMESTAMP_PATTERN.matcher(dateTime);
    if (matcher.matches()) {
        final Timestamp timestamp = Timestamp.valueOf(dateTime);
        final Calendar calendar = Calendar.getInstance();
        calendar.setTimeInMillis(timestamp.getTime());
        if (timestampTz) {
            calendar.set(Calendar.ZONE_OFFSET, 0);
            calendar.set(Calendar.DST_OFFSET, 0);
        }
        return ISO8601Utils.format(calendar.getTime(), true);
    }
    throw new SQLDataException("Invalid datetime value: " + value + ". Expected formats: yyyy-MM-dd'T'HH:mm:ss[.SSS]'Z', yyyy-MM-dd HH:mm:ss[.fffffffff]");
}
 

import java.sql.SQLDataException; //導入依賴的package包/類
private static Map<String, String> parseTags(String value) throws SQLDataException {
    if (StringUtils.isBlank(value)) {
        return Collections.emptyMap();
    }

    String[] tags = StringUtils.split(value, TAGS_DELIMETER);
    Map<String, String> result = new LinkedHashMap<>();
    Pair<String, String> nameAndValue;
    for (String tag : tags) {
        nameAndValue = parseTag(StringUtils.trim(tag));
        if (nameAndValue != null) {
            result.put(nameAndValue.getKey(), nameAndValue.getValue());
        }
    }
    return result;
}
 

import java.sql.SQLDataException; //導入依賴的package包/類
public static SQLException unboxException(SQLException exception) {
	final Throwable cause = exception.getCause();
	if (cause instanceof SQLDataException) {
		return (SQLDataException) cause;
	} else if (cause instanceof SQLFeatureNotSupportedException) {
		return (SQLFeatureNotSupportedException) cause;
	} else if (!(cause instanceof RuntimeException)) {
		return exception;
	}
	Throwable finalCause = exception;
	if (cause instanceof AtsdRuntimeException) {
		Throwable inner = cause.getCause();
		if (inner instanceof SQLException) { // parsed result from ATSD
			finalCause = cause;
		}
	}

	if (isMetricNotFoundException(cause.getMessage())) {
		return new AtsdMetricNotFoundException(exception.getMessage(), finalCause);
	} else {
		return new SQLException(exception.getMessage(), finalCause);
	}
}
 

import java.sql.SQLDataException; //導入依賴的package包/類
private Object extractSingleRow(ResultSetIterator iterator) throws SQLException {
    if (!iterator.hasNext()) {
        return null;
    }

    Map<String, Object> row = iterator.next();
    if (iterator.hasNext()) {
        throw new SQLDataException("Query result not unique for outputType=SelectOne.");
    } else if (getEndpoint().getOutputClass() != null) {
        return newBeanInstance(row);
    } else if (row.size() == 1) {
        return row.values().iterator().next();
    } else {
        return row;
    }
}
 

import java.sql.SQLDataException; //導入依賴的package包/類
/**
 * Generates Strings for RecyclerView's adapter. This data would usually come
 * from a local content provider or remote server.
 */
private void initDataset(Context ctx) {
    datasource = new SoulissDBTagHelper(ctx);
    SoulissDBHelper.open();

    try {
        collectedTag = datasource.getTag(tagId);
    } catch (SQLDataException e) {
        Log.e(Constants.TAG, "CANT LOAD tagId" + tagId);
    }
    Log.i(Constants.TAG, "initDataset loaded TAG" + tagId + " with father ID: " + collectedTag.getFatherId());

    if (!opzioni.isDbConfigured())
        AlertDialogHelper.dbNotInitedDialog(ctx);

}
 

import java.sql.SQLDataException; //導入依賴的package包/類
@Override
public boolean onOptionsItemSelected(MenuItem item) {
    int id = item.getItemId();
    switch (id) {
        case R.id.aggiungiFiglio:
            long nuovoFiglioId = datasource.createOrUpdateTag(null);

            try {
                SoulissTag figlio = datasource.getTag(nuovoFiglioId);
                figlio.setFatherId(collectedTag.getTagId());
                collectedTag.getChildTags().add(figlio);
                datasource.createOrUpdateTag(collectedTag);
            } catch (SQLDataException e) {
                e.printStackTrace();
            }
            parallaxExtAdapter.notifyItemInserted(collectedTag.getChildTags().size() - 1);
            return true;
    }
    //home e altro nel activity
    return getActivity().onOptionsItemSelected(item);
}
 

import java.sql.SQLDataException; //導入依賴的package包/類
public List<SoulissTag> getTagsByTypicals(SoulissTypical parent) {

        List<SoulissTag> comments = new ArrayList<>();
        String MY_QUERY = "SELECT * FROM " + SoulissDBOpenHelper.TABLE_TAGS_TYPICALS + " a "
                + " WHERE a." + SoulissDBOpenHelper.COLUMN_TAG_TYP_NODE_ID + " = " + parent.getNodeId()
                + " AND a." + SoulissDBOpenHelper.COLUMN_TAG_TYP_SLOT + " =  " + parent.getSlot();
        Cursor cursor = database.rawQuery(MY_QUERY, null);

        cursor.moveToFirst();
        while (!cursor.isAfterLast()) {
            int tagId = cursor.getInt(cursor.getColumnIndex(SoulissDBOpenHelper.COLUMN_TAG_TYP_TAG_ID));
            try {
                SoulissTag newTag = getTag(tagId);
                if (!comments.contains(newTag))
                    comments.add(newTag);
            } catch (SQLDataException e) {
                e.printStackTrace();
            }

            cursor.moveToNext();
        }
        // Make sure to close the cursor
        cursor.close();
        return comments;
    }
 

import java.sql.SQLDataException; //導入依賴的package包/類
public List<String> getQueries() throws SQLDataException {
    CharStream input = new ANTLRInputStream(sqlWithPlaceholders);
    ANTLRErrorListener errorListener = new InternalErrorListener();
    ParametersLexer parametersLexer = new ParametersLexer(input);
    parametersLexer.removeErrorListeners();
    parametersLexer.addErrorListener(errorListener);
    CommonTokenStream commonTokenStream = new CommonTokenStream(parametersLexer);
    ParametersParser parametersParser = new ParametersParser(commonTokenStream);
    parametersParser.removeErrorListeners();
    parametersParser.addErrorListener(errorListener);
    ParseTree parseTree = parametersParser.queries();
    ParseTreeWalker walker = new ParseTreeWalker();
    walker.walk(this, parseTree);
    if (exception.isPresent()) {
        throw exception.get();
    }
    return preparedQueries;
}