Java Code.INVALID_ARGUMENT属性代码示例

@Override
public void commit(Xid xid, boolean onePhase) throws XAException
{
	if (logger.logDebug())
	{
		debug("committing xid = " + xid + (onePhase ? " (one phase) " : " (two phase)"));
	}

	if (xid == null)
	{
		throw new CloudSpannerXAException("xid must not be null", Code.INVALID_ARGUMENT, XAException.XAER_INVAL);
	}

	if (onePhase)
	{
		commitOnePhase(xid);
	}
	else
	{
		commitPrepared(xid);
	}
}
 

private InsertWorker createInsertWithSelectStatement(Insert insert, boolean forceUpdate) throws SQLException
{
	Select select = insert.getSelect();
	if (select == null)
	{
		throw new CloudSpannerSQLException("Insert statement must contain a select statement",
				Code.INVALID_ARGUMENT);
	}
	boolean isDuplicate = insert.isUseDuplicate();
	InsertWorker.DMLOperation mode;
	if (forceUpdate)
		mode = DMLOperation.Update;
	else if (isDuplicate)
		mode = DMLOperation.OnDuplicateKeyUpdate;
	else
		mode = DMLOperation.Insert;
	return new InsertWorker(getConnection(), select, insert, getConnection().isAllowExtendedMode(), mode);
}
 

@Override
public int executeUpdate(String[] sqlTokens) throws SQLException
{
	if (sqlTokens.length != 1)
		throw new CloudSpannerSQLException(
				"Invalid argument(s) for EXECUTE_DDL_BATCH. Expected \"EXECUTE_DDL_BATCH\"",
				Code.INVALID_ARGUMENT);
	try (CloudSpannerStatement statement = getConnection().createStatement())
	{
		List<String> operations = getConnection().getAutoBatchedDdlOperations();
		for (String sql : operations)
			statement.addBatch(sql);
		statement.executeBatch();
		return operations.size();
	}
	finally
	{
		getConnection().clearAutoBatchedDdlOperations();
	}
}
 

private static void testCreateTableStatement(String sql) throws SQLException
{
	boolean isDDL = isDDLStatement(sql);
	Assert.assertTrue(isDDL);
	Statement statement = null;
	try
	{
		statement = CCJSqlParserUtil.parse(sql);
	}
	catch (JSQLParserException e)
	{
		throw new CloudSpannerSQLException("Could not parse SQL statement", Code.INVALID_ARGUMENT, e);
	}
	Assert.assertNotNull(statement);
	Assert.assertEquals(CreateTable.class, statement.getClass());
}
 

private static Select createSelect(CloudSpannerConnection connection, Delete delete) throws SQLException
{
	TableKeyMetaData table = connection.getTable(CloudSpannerDriver.unquoteIdentifier(delete.getTable().getName()));
	List<String> keyCols = table.getKeyColumns().stream()
			.map(x -> CloudSpannerDriver.quoteIdentifier(delete.getTable().getName()) + "."
					+ CloudSpannerDriver.quoteIdentifier(x))
			.collect(Collectors.toList());
	StringBuilder sql = new StringBuilder();
	sql.append("SELECT ").append(String.join(", ", keyCols));
	sql.append("\nFROM ").append(CloudSpannerDriver.quoteIdentifier(delete.getTable().getName()));
	sql.append("\nWHERE ").append(delete.getWhere().toString());

	try
	{
		return (Select) CCJSqlParserUtil.parse(sql.toString());
	}
	catch (JSQLParserException e)
	{
		throw new CloudSpannerSQLException("Could not parse generated SELECT statement: " + sql,
				Code.INVALID_ARGUMENT);
	}
}
 

private Mutation createUpdateMutation(Update update, boolean generateParameterMetaData) throws SQLException
{
	if (update.getTables().isEmpty())
		throw new CloudSpannerSQLException("No table found in update statement", Code.INVALID_ARGUMENT);
	if (update.getTables().size() > 1)
		throw new CloudSpannerSQLException("Update statements for multiple tables at once are not supported",
				Code.INVALID_ARGUMENT);
	String table = unquoteIdentifier(update.getTables().get(0).getFullyQualifiedName());
	getParameterStore().setTable(table);
	List<Expression> expressions = update.getExpressions();
	WriteBuilder builder = Mutation.newUpdateBuilder(table);
	int index = 0;
	for (Column col : update.getColumns())
	{
		String columnName = unquoteIdentifier(col.getFullyQualifiedName());
		expressions.get(index).accept(new ValueBinderExpressionVisitorAdapter<>(getParameterStore(),
				builder.set(columnName), columnName));
		index++;
	}
	visitUpdateWhereClause(update.getWhere(), builder, generateParameterMetaData);

	return builder.build();
}
 

private void visitDeleteWhereClause(Expression where, DeleteKeyBuilder keyBuilder,
		boolean generateParameterMetaData) throws SQLException
{
	if (where != null)
	{
		DMLWhereClauseVisitor whereClauseVisitor = new DMLWhereClauseVisitor(getParameterStore())
		{

			@Override
			protected void visitExpression(Column col, Expression expression)
			{
				String columnName = unquoteIdentifier(col.getFullyQualifiedName());
				keyBuilder.set(columnName);
				expression.accept(
						new KeyBuilderExpressionVisitorAdapter(getParameterStore(), columnName, keyBuilder));
			}

		};
		where.accept(whereClauseVisitor);
		if (!generateParameterMetaData && !whereClauseVisitor.isValid())
		{
			throw new CloudSpannerSQLException(INVALID_WHERE_CLAUSE_DELETE_MESSAGE, Code.INVALID_ARGUMENT);
		}
	}
}
 

/**
 * Translates a Cloud Datastore gql query string to {@link Query}.
 *
 * <p>Currently, the only way to translate a gql query string to a Query is to run the query
 * against Cloud Datastore and extract the {@code Query} from the response. To prevent reading
 * any data, we set the {@code LIMIT} to 0 but if the gql query already has a limit set, we
 * catch the exception with {@code INVALID_ARGUMENT} error code and retry the translation
 * without the zero limit.
 *
 * <p>Note: This may result in reading actual data from Cloud Datastore but the service has a
 * cap on the number of entities returned for a single rpc request, so this should not be a
 * problem in practice.
 */
@VisibleForTesting
static Query translateGqlQueryWithLimitCheck(String gql, Datastore datastore,
    String namespace) throws DatastoreException {
  String gqlQueryWithZeroLimit = gql + " LIMIT 0";
  try {
    Query translatedQuery = translateGqlQuery(gqlQueryWithZeroLimit, datastore, namespace);
    // Clear the limit that we set.
    return translatedQuery.toBuilder().clearLimit().build();
  } catch (DatastoreException e) {
    // Note: There is no specific error code or message to detect if the query already has a
    // limit, so we just check for INVALID_ARGUMENT and assume that that the query might have
    // a limit already set.
    if (e.getCode() == Code.INVALID_ARGUMENT) {
      LOG.warn("Failed to translate Gql query '{}': {}", gqlQueryWithZeroLimit, e.getMessage());
      LOG.warn("User query might have a limit already set, so trying without zero limit");
      // Retry without the zero limit.
      return translateGqlQuery(gql, datastore, namespace);
    } else {
      throw e;
    }
  }
}
 

@Override
public void setTransactionIsolation(int level) throws SQLException
{
	checkClosed();
	if (level != Connection.TRANSACTION_SERIALIZABLE)
	{
		throw new CloudSpannerSQLException(
				"Transaction level " + level
						+ " is not supported. Only Connection.TRANSACTION_SERIALIZABLE is supported",
				Code.INVALID_ARGUMENT);
	}
}
 

static CloudSpannerArray createArray(String typeName, Object[] elements) throws SQLException
{
	for (CloudSpannerDataType type : CloudSpannerDataType.values())
	{
		if (type.getTypeName().equalsIgnoreCase(typeName))
		{
			return new CloudSpannerArray(type, elements);
		}
	}
	throw new CloudSpannerSQLException("Data type " + typeName + " is unknown", Code.INVALID_ARGUMENT);
}
 

private void visitUpdateWhereClause(Expression where, WriteBuilder builder, boolean generateParameterMetaData)
		throws SQLException
{
	if (where != null)
	{
		DMLWhereClauseVisitor whereClauseVisitor = new DMLWhereClauseVisitor(getParameterStore())
		{

			@Override
			protected void visitExpression(Column col, Expression expression)
			{
				String columnName = unquoteIdentifier(col.getFullyQualifiedName());
				expression.accept(new ValueBinderExpressionVisitorAdapter<>(getParameterStore(),
						builder.set(columnName), columnName));
			}

		};
		where.accept(whereClauseVisitor);
		if (!generateParameterMetaData && !whereClauseVisitor.isValid())
		{
			throw new CloudSpannerSQLException(INVALID_WHERE_CLAUSE_UPDATE_MESSAGE, Code.INVALID_ARGUMENT);
		}
	}
	else
	{
		throw new SQLException(INVALID_WHERE_CLAUSE_UPDATE_MESSAGE);
	}
}
 

@Override
public boolean execute(String sql) throws SQLException
{
	String[] sqlTokens = getTokens(sql);
	CustomDriverStatement custom = getCustomDriverStatement(sqlTokens);
	if (custom != null)
		return custom.execute(sqlTokens);
	Statement statement = null;
	boolean ddl = isDDLStatement(sqlTokens);
	if (!ddl)
	{
		try
		{
			statement = CCJSqlParserUtil.parse(sanitizeSQL(sql));
		}
		catch (JSQLParserException | TokenMgrError e)
		{
			throw new CloudSpannerSQLException(
					"Error while parsing sql statement " + sql + ": " + e.getLocalizedMessage(),
					Code.INVALID_ARGUMENT, e);
		}
	}
	if (!ddl && statement instanceof Select)
	{
		lastResultSet = executeQuery(sql);
		lastUpdateCount = -1;
		return true;
	}
	else
	{
		lastUpdateCount = executeUpdate(sql);
		lastResultSet = null;
		return false;
	}
}
 

@Override
public ResultSet executeQuery(String[] sqlTokens) throws SQLException
{
	if (sqlTokens.length == 1)
		return getConnection().getDynamicConnectionProperties(CloudSpannerStatement.this);
	if (sqlTokens.length == 2)
		return getConnection().getDynamicConnectionProperty(CloudSpannerStatement.this, sqlTokens[1]);
	throw new CloudSpannerSQLException(
			"Invalid argument(s) for GET_CONNECTION_PROPERTY. Expected \"GET_CONNECTION_PROPERTY propertyName\" or \"GET_CONNECTION_PROPERTY\"",
			Code.INVALID_ARGUMENT);
}
 

@Override
public CloudSpannerParameterMetaData getParameterMetaData() throws SQLException
{
	// parse the SQL statement without executing it
	try
	{
		if (isDDLStatement())
		{
			throw new CloudSpannerSQLException("Cannot get parameter meta data for DDL statement",
					Code.INVALID_ARGUMENT);
		}
		Statement statement = CCJSqlParserUtil.parse(sanitizeSQL(sql));
		if (statement instanceof Insert || statement instanceof Update || statement instanceof Delete)
		{
			// Create mutation, but don't do anything with it. This
			// initializes column names of the parameter store.
			createMutations(sql, false, true);
		}
		else if (statement instanceof Select)
		{
			// Create select builder, but don't do anything with it. This
			// initializes column names of the parameter store.
			createSelectBuilder(statement, sql);
		}
	}
	catch (JSQLParserException | TokenMgrError e)
	{
		throw new CloudSpannerSQLException(PARSE_ERROR + sql + ": " + e.getLocalizedMessage(),
				Code.INVALID_ARGUMENT, e);
	}
	return new CloudSpannerParameterMetaData(this);
}
 

@Override
public ResultSet executeQuery() throws SQLException
{
	CustomDriverStatement custom = getCustomDriverStatement(sqlTokens);
	if (custom != null && custom.isQuery())
	{
		return custom.executeQuery(sqlTokens);
	}
	Statement statement;
	try
	{
		statement = CCJSqlParserUtil.parse(sanitizeSQL(sql));
	}
	catch (JSQLParserException | TokenMgrError e)
	{
		throw new CloudSpannerSQLException(PARSE_ERROR + sql + ": " + e.getLocalizedMessage(),
				Code.INVALID_ARGUMENT, e);
	}
	if (statement instanceof Select)
	{
		determineForceSingleUseReadContext((Select) statement);
		com.google.cloud.spanner.Statement.Builder builder = createSelectBuilder(statement, sql);
		try (ReadContext context = getReadContext())
		{
			com.google.cloud.spanner.ResultSet rs = context.executeQuery(builder.build());
			return new CloudSpannerResultSet(this, rs);
		}
	}
	throw new CloudSpannerSQLException("SQL statement not suitable for executeQuery. Expected SELECT-statement.",
			Code.INVALID_ARGUMENT);
}