/**************************************************************
 * 
 * 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.
 * 
 *************************************************************/


#ifndef __com_sun_star_sdbc_XStatement_idl__ 
#define __com_sun_star_sdbc_XStatement_idl__ 
 
#ifndef __com_sun_star_uno_XInterface_idl__ 
#include <com/sun/star/uno/XInterface.idl> 
#endif 
 
#ifndef __com_sun_star_sdbc_SQLException_idl__ 
#include <com/sun/star/sdbc/SQLException.idl> 
#endif 
 
 module com {  module sun {  module star {  module sdbc { 
 
 published interface XConnection; 
 published interface XResultSet; 
 
 
/** is used for executing a static SQL statement and obtaining the results
	produced by it.
	
	
	
	<p>
	Only one ResultSet per Statement can be open at any point in
	time; therefore, if the reading of one ResultSet is interleaved
	with the reading of another, each must have been generated by
	different Statements. All statement 
	<code>execute</code>
	methods implicitly
	close a statement's current ResultSet if an open one exists.
	</p>
 */
published interface XStatement: com::sun::star::uno::XInterface
{ 
	 
	/** executes a SQL statement that returns a single ResultSet.
		@param sql
			the SQL statement which should be executed
		@returns
			a ResultSet that contains the data produced by the query; never <NULL/>
		@throws SQLException 
			if a database access error occurs.
	 */
	XResultSet executeQuery([in]string sql) raises (SQLException); 
	//------------------------------------------------------------------------- 
     
	/** executes an SQL INSERT, UPDATE, or DELETE statement. In addition,
		SQL statements that return nothing, such as SQL DDL statements,
		can be executed.

		@param sql
			a SQL INSERT, UPDATE or DELETE statement or a SQL statement that returns nothing
		@returns
			either the row count for INSERT, UPDATE or DELETE or 0 for SQL statements that return nothing
		@throws SQLException 
			if a database access error occurs.
	 */
	long executeUpdate([in]string sql) raises (SQLException); 
	//------------------------------------------------------------------------- 
	 
	/** executes a SQL statement that may return multiple results.
		
		
		<p>
		Under some (uncommon) situations a single SQL statement may return
		multiple result sets and/or update counts. Normally you can ignore
		this unless you are (1) executing a stored procedure that you know may
		return multiple results or (2) you are dynamically executing an
		unknown SQL string. The navigation through multiple results is covered by
		<type scope="com::sun::star::sdbc">XMultipleResults</type>.
		</p>
		<p>
		The 
		<code>execute</code>
		method executes a SQL statement and indicates
		the form of the first result. You can then use 
		<member scope="com::sun::star::sdbc">XStatement::getResultSet()</member>
		or
		<member scope="com::sun::star::sdbc">XStatement::getUpdateCount()</member>
		to retrieve the result, and
		<member scope="com::sun::star::sdbc">XStatement::getMoreResults()</member>
		to move to any subsequent result(s).
		</p>

		@param sql
			any SQL statement
		@returns
			<TRUE/> if the next result is a ResultSet; <FALSE/> if it is an update count or there are no more results
		@throws SQLException 
			if a database access error occurs.
	 */
	boolean execute([in]string sql) raises (SQLException); 
	//------------------------------------------------------------------------- 
     
	/** returns the 
		<type scope="com::sun::star::sdbc">Connection</type>
		object
		that produced this 
		<code>Statement</code>
		object.
		@returns
			the connection that produced this statement

		@throws SQLException 
			if a database access error occurs.
	 */
	XConnection getConnection() raises (SQLException); 
}; 
 
//============================================================================= 
 
}; }; }; }; 
 
/*=========================================================================== 
===========================================================================*/ 
#endif 
