home *** CD-ROM | disk | FTP | other *** search
/ Apple Developer Connection Student Program / ADC Tools Sampler CD Disk 3 1999.iso / Metrowerks CodeWarrior / Java Support / Java_Source / Java2 / src / java / sql / PreparedStatement.java < prev    next >
Encoding:
Java Source  |  1999-05-28  |  23.0 KB  |  582 lines  |  [TEXT/CWIE]

  1. /*
  2.  * @(#)PreparedStatement.java    1.23 98/09/29
  3.  * 
  4.  * Copyright 1996-1998 by Sun Microsystems, Inc.,
  5.  * 901 San Antonio Road, Palo Alto, California, 94303, U.S.A.
  6.  * All rights reserved.
  7.  *
  8.  * This software is the confidential and proprietary information
  9.  * of Sun Microsystems, Inc. ("Confidential Information").  You
  10.  * shall not disclose such Confidential Information and shall use
  11.  * it only in accordance with the terms of the license agreement
  12.  * you entered into with Sun.
  13.  */
  14.  
  15. package java.sql;
  16.  
  17. import java.math.BigDecimal;
  18. import java.util.Calendar;
  19.  
  20. /**
  21.  * An object that represents a precompiled SQL statement.
  22.  * <P>A SQL statement is pre-compiled and stored in a
  23.  * PreparedStatement object. This object can then be used to
  24.  * efficiently execute this statement multiple times. 
  25.  *
  26.  * <P><B>Note:</B> The setXXX methods for setting IN parameter values
  27.  * must specify types that are compatible with the defined SQL type of
  28.  * the input parameter. For instance, if the IN parameter has SQL type
  29.  * Integer, then the method <code>setInt</code> should be used.
  30.  *
  31.  * <p>If arbitrary parameter type conversions are required, the method
  32.  * <code>setObject</code> should be used with a target SQL type.
  33.  * <br>
  34.  * Example of setting a parameter; <code>con</code> is an active connection  
  35.  * <pre><code>
  36.  *   PreparedStatement pstmt = con.prepareStatement("UPDATE EMPLOYEES
  37.  *                                     SET SALARY = ? WHERE ID = ?");
  38.  *   pstmt.setBigDecimal(1, 153833.00)
  39.  *   pstmt.setInt(2, 110592)
  40.  * </code></pre>
  41.  *
  42.  * @see Connection#prepareStatement
  43.  * @see ResultSet 
  44.  */
  45.  
  46. public interface PreparedStatement extends Statement {
  47.  
  48.     /**
  49.      * Executes the SQL query in this <code>PreparedStatement</code> object
  50.      * and returns the result set generated by the query.
  51.      *
  52.      * @return a ResultSet that contains the data produced by the
  53.      * query; never null
  54.      * @exception SQLException if a database access error occurs
  55.      */
  56.     ResultSet executeQuery() throws SQLException;
  57.  
  58.     /**
  59.      * Executes the SQL INSERT, UPDATE or DELETE statement
  60.      * in this <code>PreparedStatement</code> object.
  61.      * In addition,
  62.      * SQL statements that return nothing, such as SQL DDL statements,
  63.      * can be executed.
  64.      *
  65.      * @return either the row count for INSERT, UPDATE or DELETE statements;
  66.      * or 0 for SQL statements that return nothing
  67.      * @exception SQLException if a database access error occurs
  68.      */
  69.     int executeUpdate() throws SQLException;
  70.  
  71.     /**
  72.      * Sets the designated parameter to SQL NULL.
  73.      *
  74.      * <P><B>Note:</B> You must specify the parameter's SQL type.
  75.      *
  76.      * @param parameterIndex the first parameter is 1, the second is 2, ...
  77.      * @param sqlType the SQL type code defined in java.sql.Types
  78.      * @exception SQLException if a database access error occurs
  79.      */
  80.     void setNull(int parameterIndex, int sqlType) throws SQLException;
  81.  
  82.     /**
  83.      * Sets the designated parameter to a Java boolean value.  The driver converts this
  84.      * to an SQL BIT value when it sends it to the database.
  85.      *
  86.      * @param parameterIndex the first parameter is 1, the second is 2, ...
  87.      * @param x the parameter value
  88.      * @exception SQLException if a database access error occurs
  89.      */
  90.     void setBoolean(int parameterIndex, boolean x) throws SQLException;
  91.  
  92.     /**
  93.      * Sets the designated parameter to a Java byte value.  The driver converts this
  94.      * to an SQL TINYINT value when it sends it to the database.
  95.      *
  96.      * @param parameterIndex the first parameter is 1, the second is 2, ...
  97.      * @param x the parameter value
  98.      * @exception SQLException if a database access error occurs
  99.      */
  100.     void setByte(int parameterIndex, byte x) throws SQLException;
  101.  
  102.     /**
  103.      * Sets the designated parameter to a Java short value.  The driver converts this
  104.      * to an SQL SMALLINT value when it sends it to the database.
  105.      *
  106.      * @param parameterIndex the first parameter is 1, the second is 2, ...
  107.      * @param x the parameter value
  108.      * @exception SQLException if a database access error occurs
  109.      */
  110.     void setShort(int parameterIndex, short x) throws SQLException;
  111.  
  112.     /**
  113.      * Sets the designated parameter to a Java int value.  The driver converts this
  114.      * to an SQL INTEGER value when it sends it to the database.
  115.      *
  116.      * @param parameterIndex the first parameter is 1, the second is 2, ...
  117.      * @param x the parameter value
  118.      * @exception SQLException if a database access error occurs
  119.      */
  120.     void setInt(int parameterIndex, int x) throws SQLException;
  121.  
  122.     /**
  123.      * Sets the designated parameter to a Java long value.  The driver converts this
  124.      * to an SQL BIGINT value when it sends it to the database.
  125.      *
  126.      * @param parameterIndex the first parameter is 1, the second is 2, ...
  127.      * @param x the parameter value
  128.      * @exception SQLException if a database access error occurs
  129.      */
  130.     void setLong(int parameterIndex, long x) throws SQLException;
  131.  
  132.     /**
  133.      * Sets the designated parameter to a Java float value.  The driver converts this
  134.      * to an SQL FLOAT value when it sends it to the database.
  135.      *
  136.      * @param parameterIndex the first parameter is 1, the second is 2, ...
  137.      * @param x the parameter value
  138.      * @exception SQLException if a database access error occurs
  139.      */
  140.     void setFloat(int parameterIndex, float x) throws SQLException;
  141.  
  142.     /**
  143.      * Sets the designated parameter to a Java double value.  The driver converts this
  144.      * to an SQL DOUBLE value when it sends it to the database.
  145.      *
  146.      * @param parameterIndex the first parameter is 1, the second is 2, ...
  147.      * @param x the parameter value
  148.      * @exception SQLException if a database access error occurs
  149.      */
  150.     void setDouble(int parameterIndex, double x) throws SQLException;
  151.  
  152.     /**
  153.      * Sets the designated parameter to a java.lang.BigDecimal value.  
  154.      * The driver converts this to an SQL NUMERIC value when
  155.      * it sends it to the database.
  156.      *
  157.      * @param parameterIndex the first parameter is 1, the second is 2, ...
  158.      * @param x the parameter value
  159.      * @exception SQLException if a database access error occurs
  160.      */
  161.     void setBigDecimal(int parameterIndex, BigDecimal x) throws SQLException;
  162.  
  163.     /**
  164.      * Sets the designated parameter to a Java String value.  The driver converts this
  165.      * to an SQL VARCHAR or LONGVARCHAR value (depending on the argument's
  166.      * size relative to the driver's limits on VARCHARs) when it sends
  167.      * it to the database.
  168.      *
  169.      * @param parameterIndex the first parameter is 1, the second is 2, ...
  170.      * @param x the parameter value
  171.      * @exception SQLException if a database access error occurs
  172.      */
  173.     void setString(int parameterIndex, String x) throws SQLException;
  174.  
  175.     /**
  176.      * Sets the designated parameter to a Java array of bytes.  The driver converts
  177.      * this to an SQL VARBINARY or LONGVARBINARY (depending on the
  178.      * argument's size relative to the driver's limits on VARBINARYs)
  179.      * when it sends it to the database.
  180.      *
  181.      * @param parameterIndex the first parameter is 1, the second is 2, ...
  182.      * @param x the parameter value 
  183.      * @exception SQLException if a database access error occurs
  184.      */
  185.     void setBytes(int parameterIndex, byte x[]) throws SQLException;
  186.  
  187.     /**
  188.      * Sets the designated parameter to a java.sql.Date value.  The driver converts this
  189.      * to an SQL DATE value when it sends it to the database.
  190.      *
  191.      * @param parameterIndex the first parameter is 1, the second is 2, ...
  192.      * @param x the parameter value
  193.      * @exception SQLException if a database access error occurs
  194.      */
  195.     void setDate(int parameterIndex, java.sql.Date x)
  196.         throws SQLException;
  197.  
  198.     /**
  199.      * Sets the designated parameter to a java.sql.Time value.  The driver converts this
  200.      * to an SQL TIME value when it sends it to the database.
  201.      *
  202.      * @param parameterIndex the first parameter is 1, the second is 2, ...
  203.      * @param x the parameter value
  204.      * @exception SQLException if a database access error occurs
  205.      */
  206.     void setTime(int parameterIndex, java.sql.Time x) 
  207.         throws SQLException;
  208.  
  209.     /**
  210.      * Sets the designated parameter to a java.sql.Timestamp value.  The driver
  211.      * converts this to an SQL TIMESTAMP value when it sends it to the
  212.      * database.
  213.      *
  214.      * @param parameterIndex the first parameter is 1, the second is 2, ...
  215.      * @param x the parameter value 
  216.      * @exception SQLException if a database access error occurs
  217.      */
  218.     void setTimestamp(int parameterIndex, java.sql.Timestamp x)
  219.         throws SQLException;
  220.  
  221.     /**
  222.      * Sets the designated parameter to the given input stream, which will have 
  223.      * the specified number of bytes.
  224.      * When a very large ASCII value is input to a LONGVARCHAR
  225.      * parameter, it may be more practical to send it via a
  226.      * java.io.InputStream. JDBC will read the data from the stream
  227.      * as needed, until it reaches end-of-file.  The JDBC driver will
  228.      * do any necessary conversion from ASCII to the database char format.
  229.      * 
  230.      * <P><B>Note:</B> This stream object can either be a standard
  231.      * Java stream object or your own subclass that implements the
  232.      * standard interface.
  233.      *
  234.      * @param parameterIndex the first parameter is 1, the second is 2, ...
  235.      * @param x the Java input stream that contains the ASCII parameter value
  236.      * @param length the number of bytes in the stream 
  237.      * @exception SQLException if a database access error occurs
  238.      */
  239.     void setAsciiStream(int parameterIndex, java.io.InputStream x, int length)
  240.         throws SQLException;
  241.  
  242.     /**
  243.      * Sets the designated parameter to the given input stream, which will have 
  244.      * the specified number of bytes.
  245.      * When a very large UNICODE value is input to a LONGVARCHAR
  246.      * parameter, it may be more practical to send it via a
  247.      * java.io.InputStream. JDBC will read the data from the stream
  248.      * as needed, until it reaches end-of-file.  The JDBC driver will
  249.      * do any necessary conversion from UNICODE to the database char format.
  250.      * The byte format of the Unicode stream must be Java UTF-8, as
  251.      * defined in the Java Virtual Machine Specification.
  252.      * 
  253.      * <P><B>Note:</B> This stream object can either be a standard
  254.      * Java stream object or your own subclass that implements the
  255.      * standard interface.
  256.      *
  257.      * @param parameterIndex the first parameter is 1, the second is 2, ...  
  258.      * @param x the java input stream which contains the
  259.      * UNICODE parameter value 
  260.      * @param length the number of bytes in the stream 
  261.      * @exception SQLException if a database access error occurs
  262.      * @deprecated
  263.      */
  264.     void setUnicodeStream(int parameterIndex, java.io.InputStream x, 
  265.               int length) throws SQLException;
  266.  
  267.     /**
  268.      * Sets the designated parameter to the given input stream, which will have 
  269.      * the specified number of bytes.
  270.      * When a very large binary value is input to a LONGVARBINARY
  271.      * parameter, it may be more practical to send it via a
  272.      * java.io.InputStream. JDBC will read the data from the stream
  273.      * as needed, until it reaches end-of-file.
  274.      * 
  275.      * <P><B>Note:</B> This stream object can either be a standard
  276.      * Java stream object or your own subclass that implements the
  277.      * standard interface.
  278.      *
  279.      * @param parameterIndex the first parameter is 1, the second is 2, ...
  280.      * @param x the java input stream which contains the binary parameter value
  281.      * @param length the number of bytes in the stream 
  282.      * @exception SQLException if a database access error occurs
  283.      */
  284.     void setBinaryStream(int parameterIndex, java.io.InputStream x, 
  285.              int length) throws SQLException;
  286.  
  287.     /**
  288.      * Clears the current parameter values immediately.
  289.      * <P>In general, parameter values remain in force for repeated use of a
  290.      * Statement. Setting a parameter value automatically clears its
  291.      * previous value.  However, in some cases it is useful to immediately
  292.      * release the resources used by the current parameter values; this can
  293.      * be done by calling clearParameters.
  294.      *
  295.      * @exception SQLException if a database access error occurs
  296.      */
  297.     void clearParameters() throws SQLException;
  298.  
  299.     //----------------------------------------------------------------------
  300.     // Advanced features:
  301.  
  302.     /**
  303.      * <p>Sets the value of a parameter using an object. The second
  304.      * argument must be an object type; for integral values, the
  305.      * java.lang equivalent objects should be used.
  306.      *
  307.      * <p>The given Java object will be converted to the targetSqlType
  308.      * before being sent to the database.
  309.      *
  310.      * If the object has a custom mapping (is of a class implementing SQLData),
  311.      * the JDBC driver should call its method <code>writeSQL</code> to write it 
  312.      * to the SQL data stream.
  313.      * If, on the other hand, the object is of a class implementing
  314.      * Ref, Blob, Clob, Struct, 
  315.      * or Array, the driver should pass it to the database as a value of the 
  316.      * corresponding SQL type.
  317.      *
  318.      * <p>Note that this method may be used to pass datatabase-
  319.      * specific abstract data types. 
  320.      *
  321.      * @param parameterIndex the first parameter is 1, the second is 2, ...
  322.      * @param x the object containing the input parameter value
  323.      * @param targetSqlType the SQL type (as defined in java.sql.Types) to be 
  324.      * sent to the database. The scale argument may further qualify this type.
  325.      * @param scale for java.sql.Types.DECIMAL or java.sql.Types.NUMERIC types,
  326.      *          this is the number of digits after the decimal point.  For all other
  327.      *          types, this value will be ignored.
  328.      * @exception SQLException if a database access error occurs
  329.      * @see Types 
  330.      */
  331.     void setObject(int parameterIndex, Object x, int targetSqlType, int scale)
  332.             throws SQLException;
  333.  
  334.    /**
  335.      * Sets the value of the designated parameter with the given object.
  336.      * This method is like setObject above, except that it assumes a scale of zero.
  337.      *
  338.      * @param parameterIndex the first parameter is 1, the second is 2, ...
  339.      * @param x the object containing the input parameter value
  340.      * @param targetSqlType the SQL type (as defined in java.sql.Types) to be 
  341.      *                      sent to the database
  342.      * @exception SQLException if a database access error occurs
  343.      */
  344.     void setObject(int parameterIndex, Object x, int targetSqlType) 
  345.       throws SQLException;
  346.  
  347.     /**
  348.      * <p>Sets the value of a parameter using an object; use the
  349.      * java.lang equivalent objects for integral values.
  350.      *
  351.      * <p>The JDBC specification specifies a standard mapping from
  352.      * Java Object types to SQL types.  The given argument java object
  353.      * will be converted to the corresponding SQL type before being
  354.      * sent to the database.
  355.      *
  356.      * <p>Note that this method may be used to pass datatabase-
  357.      * specific abstract data types, by using a Driver-specific Java
  358.      * type.
  359.      *
  360.      * If the object is of a class implementing SQLData,
  361.      * the JDBC driver should call its method <code>writeSQL</code> to write it 
  362.      * to the SQL data stream.
  363.      * If, on the other hand, the object is of a class implementing
  364.      * Ref, Blob, Clob, Struct, 
  365.      * or Array, then the driver should pass it to the database as a value of the 
  366.      * corresponding SQL type.
  367.      *
  368.      * This method throws an exception if there is an ambiguity, for example, if the
  369.      * object is of a class implementing more than one of those interfaces.
  370.      *
  371.      * @param parameterIndex the first parameter is 1, the second is 2, ...
  372.      * @param x the object containing the input parameter value 
  373.      * @exception SQLException if a database access error occurs
  374.      */
  375.     void setObject(int parameterIndex, Object x) throws SQLException;
  376.  
  377.     /**
  378.      * Executes any kind of SQL statement.
  379.      * Some prepared statements return multiple results; the execute
  380.      * method handles these complex statements as well as the simpler
  381.      * form of statements handled by executeQuery and executeUpdate.
  382.      *
  383.      * @exception SQLException if a database access error occurs
  384.      * @see Statement#execute
  385.      */
  386.     boolean execute() throws SQLException;
  387.  
  388.     //--------------------------JDBC 2.0-----------------------------
  389.  
  390.     /**
  391.      * JDBC 2.0
  392.      *
  393.      * Adds a set of parameters to the batch.
  394.      * 
  395.      * @exception SQLException if a database access error occurs
  396.      * @see Statement#addBatch
  397.      */
  398.     void addBatch() throws SQLException;
  399.  
  400.     /**
  401.      * JDBC 2.0
  402.      *
  403.      * Sets the designated parameter to the given <code>Reader</code>
  404.      * object, which is the given number of characters long.
  405.      * When a very large UNICODE value is input to a LONGVARCHAR
  406.      * parameter, it may be more practical to send it via a
  407.      * java.io.Reader. JDBC will read the data from the stream
  408.      * as needed, until it reaches end-of-file.  The JDBC driver will
  409.      * do any necessary conversion from UNICODE to the database char format.
  410.      * 
  411.      * <P><B>Note:</B> This stream object can either be a standard
  412.      * Java stream object or your own subclass that implements the
  413.      * standard interface.
  414.      *
  415.      * @param parameterIndex the first parameter is 1, the second is 2, ...
  416.      * @param x the java reader which contains the UNICODE data
  417.      * @param length the number of characters in the stream 
  418.      * @exception SQLException if a database access error occurs
  419.      */
  420.     void setCharacterStream(int parameterIndex,
  421.                      java.io.Reader reader,
  422.               int length) throws SQLException;
  423.  
  424.     /**
  425.      * JDBC 2.0
  426.      *
  427.      * Sets a REF(<structured-type>) parameter.
  428.      *
  429.      * @param i the first parameter is 1, the second is 2, ...
  430.      * @param x an object representing data of an SQL REF Type
  431.      * @exception SQLException if a database access error occurs
  432.      */
  433.     void setRef (int i, Ref x) throws SQLException;
  434.  
  435.     /**
  436.      * JDBC 2.0
  437.      *
  438.      * Sets a BLOB parameter.
  439.      *
  440.      * @param i the first parameter is 1, the second is 2, ...
  441.      * @param x an object representing a BLOB
  442.      * @exception SQLException if a database access error occurs
  443.      */
  444.     void setBlob (int i, Blob x) throws SQLException;
  445.  
  446.     /**
  447.      * JDBC 2.0
  448.      *
  449.      * Sets a CLOB parameter.
  450.      *
  451.      * @param i the first parameter is 1, the second is 2, ...
  452.      * @param x an object representing a CLOB
  453.      * @exception SQLException if a database access error occurs
  454.      */
  455.     void setClob (int i, Clob x) throws SQLException;
  456.  
  457.     /**
  458.      * JDBC 2.0
  459.      *
  460.      * Sets an Array parameter.
  461.      *
  462.      * @param i the first parameter is 1, the second is 2, ...
  463.      * @param x an object representing an SQL array
  464.      * @exception SQLException if a database access error occurs
  465.      */
  466.     void setArray (int i, Array x) throws SQLException;
  467.  
  468.     /**
  469.      * JDBC 2.0
  470.      *
  471.      * Gets the number, types and properties of a ResultSet's columns.
  472.      *
  473.      * @return the description of a ResultSet's columns
  474.      * @exception SQLException if a database access error occurs
  475.      */
  476.     ResultSetMetaData getMetaData() throws SQLException;
  477.  
  478.     /**
  479.      * JDBC 2.0
  480.      *
  481.      * Sets the designated parameter to a java.sql.Date value,
  482.      * using the given <code>Calendar</code> object.  The driver uses
  483.      * the <code>Calendar</code> object to construct an SQL DATE,
  484.      * which the driver then sends to the database.  With a
  485.      * a <code>Calendar</code> object, the driver can calculate the date
  486.      * taking into account a custom timezone and locale.  If no
  487.      * <code>Calendar</code> object is specified, the driver uses the default
  488.      * timezone and locale.
  489.      *
  490.      * @param parameterIndex the first parameter is 1, the second is 2, ...
  491.      * @param x the parameter value
  492.      * @param cal the <code>Calendar</code> object the driver will use
  493.      *            to construct the date
  494.      * @exception SQLException if a database access error occurs
  495.      */
  496.     void setDate(int parameterIndex, java.sql.Date x, Calendar cal)
  497.         throws SQLException;
  498.  
  499.     /**
  500.      * JDBC 2.0
  501.      *
  502.      * Sets the designated parameter to a java.sql.Time value,
  503.      * using the given <code>Calendar</code> object.  The driver uses
  504.      * the <code>Calendar</code> object to construct an SQL TIME,
  505.      * which the driver then sends to the database.  With a
  506.      * a <code>Calendar</code> object, the driver can calculate the time
  507.      * taking into account a custom timezone and locale.  If no
  508.      * <code>Calendar</code> object is specified, the driver uses the default
  509.      * timezone and locale.
  510.      *
  511.      * @param parameterIndex the first parameter is 1, the second is 2, ...
  512.      * @param x the parameter value
  513.      * @param cal the <code>Calendar</code> object the driver will use
  514.      *            to construct the time
  515.      * @exception SQLException if a database access error occurs
  516.      */
  517.     void setTime(int parameterIndex, java.sql.Time x, Calendar cal) 
  518.         throws SQLException;
  519.  
  520.     /**
  521.      * JDBC 2.0
  522.      *
  523.      * Sets the designated parameter to a java.sql.Timestamp value,
  524.      * using the given <code>Calendar</code> object.  The driver uses
  525.      * the <code>Calendar</code> object to construct an SQL TIMESTAMP,
  526.      * which the driver then sends to the database.  With a
  527.      * a <code>Calendar</code> object, the driver can calculate the timestamp
  528.      * taking into account a custom timezone and locale.  If no
  529.      * <code>Calendar</code> object is specified, the driver uses the default
  530.      * timezone and locale.
  531.      *
  532.      * @param parameterIndex the first parameter is 1, the second is 2, ...
  533.      * @param x the parameter value 
  534.      * @param cal the <code>Calendar</code> object the driver will use
  535.      *            to construct the timestamp
  536.      * @exception SQLException if a database access error occurs
  537.      */
  538.     void setTimestamp(int parameterIndex, java.sql.Timestamp x, Calendar cal)
  539.         throws SQLException;
  540.  
  541.     /**
  542.      * JDBC 2.0
  543.      *
  544.      * Sets the designated parameter to SQL NULL.  This version of setNull should
  545.      * be used for user-named types and REF type parameters.  Examples
  546.      * of user-named types include: STRUCT, DISTINCT, JAVA_OBJECT, and 
  547.      * named array types.
  548.      *
  549.      * <P><B>Note:</B> To be portable, applications must give the
  550.      * SQL type code and the fully-qualified SQL type name when specifying
  551.      * a NULL user-defined or REF parameter.  In the case of a user-named type 
  552.      * the name is the type name of the parameter itself.  For a REF 
  553.      * parameter the name is the type name of the referenced type.  If 
  554.      * a JDBC driver does not need the type code or type name information, 
  555.      * it may ignore it.     
  556.      *
  557.      * Although it is intended for user-named and Ref parameters,
  558.      * this method may be used to set a null parameter of any JDBC type.
  559.      * If the parameter does not have a user-named or REF type, the given
  560.      * typeName is ignored.
  561.      *
  562.      *
  563.      * @param parameterIndex the first parameter is 1, the second is 2, ...
  564.      * @param sqlType a value from java.sql.Types
  565.      * @param typeName the fully-qualified name of an SQL user-named type,
  566.      *  ignored if the parameter is not a user-named type or REF 
  567.      * @exception SQLException if a database access error occurs
  568.      */
  569.   void setNull (int paramIndex, int sqlType, String typeName) 
  570.     throws SQLException;
  571. }
  572.  
  573.  
  574.  
  575.  
  576.  
  577.  
  578.  
  579.  
  580.  
  581.  
  582.