Database (de.mpg.mpi-inf:javatools 1.1 API)

java.lang.Object
- javatools.database.Database

Direct Known Subclasses:

DummyDatabase, MySQLDatabase, OracleDatabase, PostgresDatabase
```
public abstract class Database
extends Object
```
Copyright 2016 Fabian M. Suchanek Licensed 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. This abstract class provides a simple Wrapper for an SQL data base. It is implemented by OracleDatabase, PostgresDatabase and MySQLDatabase.
Example:
```
 
 Database d=new OracleDatabase("user","password"); 
 for(String food : d.query("SELECT foodname FROM food", ResultIterator.StringWrapper)) {
   System.out.print(food);
 } 
 -> Pizza Spaghetti Saltimbocca
 
```
It is possible to execute multiple INSERT statements by a bulk loader:
```
   d=new OracleDatabase(...);
   Database.Inserter i=d.newInserter(tableName);
   i.insert(7,"Hallo");
   i.insert(8,"Ciao");   
   ...
   i.close();
 
```
The inserters are automatically flushed every 1000 insertions and when closed. They are flushed and closed when the database is closed.
Unfortunately, the same datatype is called differently on different database systems, behaves differently and is written down differently. There is an ANSI standard, but of course nobody cares. This is why Database.java provides a method getSQLType(int), which takes any of the SQL datatypes defined in java.sql.Types (e.g. VARCHAR) and returns an object of the class javatools.SQLType. This object then behaves according to the conventions of the respective database system. Each implementation of Database.java should return SQLType-objects tailored to the specific database (e.g. OracleDatabase maps BOOLEAN to NUMBER(1) and replaces quotes in string literals by double quotes). By default, the ANSI datatypes are returned.
Example:
```
 
 Database d=new OracleDatabase("user","password");
 d.getSQLType(java.sql.Types.VARCHAR).format("Bobby's") 
 -> 'Bobby"s' 
 
 d=new MySQLDatabase("user","password","database");
 d.getSQLType(java.sql.Types.VARCHAR).format("Bobby's") 
 -> 'Bobby\'s'
 
 
```
Technical issues: Implementations of Database.java can extend the ANSI type classes given in SQLType.java and they can modify the maps java2SQL and type2SQL provided by Database.java. See OracleDatabase.java for an example. For each datatype class, there should only be one instance (per scale). Unfortunately, Java does not allow instances to have different method implementation, so that each datatype has to be a class. It would be convenient to handle datatypes as enums, but enums cannot be extended. To facilitate modifying the ANSI types for subclasses, the getSQLType-method is non-static. Implementations of this class should have a noarg-constructor to enable calls to getSQLType without establishing a database connection.

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`Database.CommitTransactionSQLException`
`static class`	`Database.ConnectionBrokenSQLException` Exceptions ****
`static class`	`Database.InitTransactionSQLException`
`class`	`Database.Inserter` Represents a bulk loader
`static class`	`Database.RollbackTransactionSQLException`
`static class`	`Database.StartAutoCommitSQLException`
`static class`	`Database.TransactionSQLException`

Field Summary

Fields
Modifier and Type	Field and Description
`protected Connection`	`connection` Handle for the database
`protected String`	`description` /** Describes this database
`protected Driver`	`driver` The Driver registered for this database instance TODO: it may be more reasonable to share the same driver instance for all database insances of the same type...check that and adapt
`protected int`	`fetchsize` The fetchsize to be used on default, i.e.
`protected List<Database.Inserter>`	`inserters` Holds all active inserters to close them in the end
`Map<Class<?>,SQLType>`	`java2SQL` The mapping from Java to SQL
`static int`	`MINCOLUMNWIDTH` The minal column width for describe()
`protected int`	`resultSetConcurrency` The concurrency type of the resultSet (read only by default)
`protected int`	`resultSetType` The type of the resultSet (Forward only by default)
`static int`	`SCREENWIDTH` The screen width for describe()
`Map<Integer,SQLType>`	`type2SQL` The mapping from type codes (as defined in java.sql.Types) to SQL

Constructor Summary

Constructors
Constructor and Description

Database()

Constructors
Constructor and Description
`Database()`

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`protected static void`	`appendFixedLen(StringBuilder b, Object o, int len)` Appends something to a StringBuilder with a fixed length
`protected void`	`attemptReconnect(SQLException cause, boolean autoReconnect)` called when query execution failed due to some exception; checks connectivity and if connection is broken may attempt to reconnect depending on the given parameters, if the connection is still alive, reconnection fails or autoReconnect is not enabled throws a fitting exception
`String`	`autoincrementColumn()` Produces an SQL fragment representing an autoincrementing column type s.t.
`String`	`cast(String value, String type)` Produces an SQL fragment casting the given value to the given type *
`void`	`close()` Closes the connection
`static void`	`close(Connection connection)` Closes a connection
`static void`	`close(ResultSet rs)` Closes a result set
`static void`	`close(Statement statement)` Closes a statement
`protected void`	`commitTransaction()` commits the transaction aggregated so far if the commit fails the transaction is rolled back!
`abstract void`	`connect()` connects to the database specified
`boolean`	`connected()` Checks whether the connection to the database is still alive
`void`	`createIndex(String table, boolean unique, String... attributes)`
`String`	`createIndexCommand(String table, boolean unique, String... attributes)` Returns the command to create one index on a table
`void`	`createIndices(String table, String... attributes)` Creates non-unique single indices on a table
`void`	`createPrimaryKey(String table, String... attributes)` makes the given attributes/columns the primary key of the given table
`void`	`createTable(String name, Object... attributes)` Creates or rewrites an SQL table.
`void`	`createView(String name, String query)` creates a view with given name over the query
`static String`	`describe(ResultSet r)` Returns a String-representation of a ResultSet
`static String`	`describe(ResultSet r, int maxrows)` Returns a String-representation of a ResultSet, maximally maxrows rows (or all for -1)
`void`	`dumpCSV(String table, File output, char separator)` Produces a CSV version of the table
`void`	`dumpQueryAsCSV(String selectCommand, File output, char separator)` Produces a CSV version of the query
`void`	`endTransaction()` executes the transaction and switches back from transaction mode into autocommit mode
`void`	`endTransaction(boolean flush)` Deprecated.
`protected ResultSet`	`executeQuery(String sql, int resultSetType, int resultSetConcurrency, Integer fetchsize)` Returns the results for a query as a ResultSet with given type, concurrency and fetchsize.
`int`	`executeUpdate(CharSequence sqlcs)` Executes an SQL update query, returns the number of rows added/deleted
`protected int`	`executeUpdateQuery(String sqlcs)` Executes an SQL update query, returns the number of rows added/deleted
`boolean`	`exists(CharSequence sql)` Returns TRUE if the resultset is not empty
`boolean`	`existsTable(String table)` checks if a table with the given name exists (or rather whether it can be accessed).
`void`	`finalize()` Closes the connection
`void`	`flush()` Flush the connection
`String`	`format(Object o)` Formats an object appropriately (provided that its class is in java2SQL)
`String`	`formatNullToNull(Object o)` Formats an object appropriately (provided that its class is in java2SQL) and assigns NULL if the given object is a null pointer
`Connection`	`getConnection()` Returns the connection
`int`	`getFetchsize()` gets the current default fetchsize affecting all queries where no specific fetchsize is provided as query argument The fetchsize determines how many result rows are pulled in from the server at once.
`int`	`getResultSetConcurrency()` Returns the resultSetConcurrency
`int`	`getResultSetType()` Returns the resultSetType
`String`	`getSQLStmntIFNULL(String a, String b)` returns the database system specific expression for if-null functionality i.e.
`SQLType`	`getSQLType(Class<?> c)` Returns an SQLType for the given class
`SQLType`	`getSQLType(int t)` Returns an SQLType for the given Type as defined in java.sql.Types
`SQLType`	`getSQLType(int t, int scale)` Returns an SQLType for the given Type as defined in java.sql.Types with a scale
`int`	`getValidityCheckTimeout()` time in milliseconds after which a connection is considered broken when no answer is received within that time frame
`String`	`indexName(String table, String... attributes)` Creates an index name
`boolean`	`isAutoReconnectingOnSelect()` indicates whether automatic reconnection and requerying is attempted when a broken connection is discovered after an informative (SELECT) query if this is set to false, a ConnectionBrokenSQLException is thrown instead
`boolean`	`isAutoReconnectingOnUpdate()` indicates whether automatic reconnection and requerying is attempted when a broken connection is discovered after an update (INSERT, UPDATE) query if this is set to false, a ConnectionBrokenSQLException is thrown instead Note: In rare cases this may lead to an update query being executed twice, so treat with care!
`boolean`	`jarAvailable()` TRUE if the required JAR is there
`String`	`limit(String sql, int n)` Makes an SQL query limited to n results
`void`	`loadCSV(String table, File input, boolean clearTable, char separator)` Loads a CSV file into a table
`void`	`lockTableReadAccess(Map<String,String> tableAndAliases)` Locks a table in read mode, i.e.
`void`	`lockTableWriteAccess(Map<String,String> tableAndAliases)` Locks a table in write mode, i.e.
`static void`	`main(String[] args)` Test routine
`void`	`makeCSV(String table, File output, char separator)` Produces a CSV version of the table
`void`	`makeCSVForQuery(String selectCommand, File output, char separator)` Produces a CSV version of the query
`Database.Inserter`	`newInserter(String table)` Returns an inserter for a table with specific column types
`Database.Inserter`	`newInserter(String table, Class<?>... argumentTypes)` Returns an inserter for a table with specific column types
`Database.Inserter`	`newInserter(String table, int... argumentTypes)` Returns an inserter for a table with specific column types given as java.sql.Type constants
`String`	`offset(String sql, int n)` Makes sure a query response starts at the n-th result
`protected String`	`prepareQuery(String sql)` Prepares the query internally for a call (e.g.
`ResultSet`	`query(CharSequence sql)` Returns the results for a query as a ResultSet with default type and concurrency (read comments!).
`ResultSet`	`query(CharSequence sqlcs, int resultSetType, int resultSetConcurrency)` Returns the results for a query as a ResultSet with given type and concurrency.
`ResultSet`	`query(CharSequence sqlcs, int resultSetType, int resultSetConcurrency, Integer fetchsize)` Returns the results for a query as a ResultSet with given type, concurrency and fetchsize.
`<T> ResultIterator<T>`	`query(CharSequence sql, ResultIterator.ResultWrapper<T> rc)` Returns the results for a query as a ResultIterator
`<T> T`	`queryValue(CharSequence sql, ResultIterator.ResultWrapper<T> rc)` Returns a single value (or null)
`void`	`reconnect()` (re-)connects to the database specified
`void`	`releaseLocksAndEndTransaction()` releases all locks the connection holds, commits the current transaction and ends it
`void`	`resetTransaction()` resets the transaction rolling it back and closing it
`void`	`runInterface()` Runs a user-interface and closes
`void`	`setAutoReconnectOnSelect(boolean autoReconnectOnSelect)` enable/disable automatic reconnection and requerying when a broken connection is discovered after an informative (SELECT) query if this is set to false, a ConnectionBrokenSQLException is thrown instead
`void`	`setAutoReconnectOnUpdate(boolean autoReconnectOnUpdate)` enables/disables whether automatic reconnection and requerying is attempted when a broken connection is discovered after an update (INSERT, UPDATE) query if this is set to false, a ConnectionBrokenSQLException is thrown instead Note: In rare cases this may lead to an update query being executed twice, so treat with care!
`void`	`setFetchsize(int fetchsize)` sets the default fetchsize affecting all following queries where no specific fetchsize is provided as query argument The fetchsize determines how many result rows are pulled in from the server at once.
`void`	`setResultSetConcurrency(int resultSetConcurrency)` Sets the resultSetConcurrency
`void`	`setResultSetType(int resultSetType)` Sets the resultSetType
`void`	`setValidityCheckTimeout(int validityCheckTimeout)` sets the amount of time a database has to answer to a connection probing before the connection is considered broken Note: the value cannot be smaller than 0
`void`	`startTransaction()` Initiates a transaction by disabling autocommit and enabling transaction mode
`String`	`toString()` Misc.

Methods inherited from class java.lang.Object
clone, equals, getClass, hashCode, notify, notifyAll, wait, wait, wait

- Field Detail
  - connection
```
protected Connection connection
```
    Handle for the database
  - description
```
protected String description
```
    /** Describes this database
  - resultSetType
```
protected int resultSetType
```
    The type of the resultSet (Forward only by default)
  - resultSetConcurrency
```
protected int resultSetConcurrency
```
    The concurrency type of the resultSet (read only by default)
  - fetchsize
```
protected int fetchsize
```
    The fetchsize to be used on default, i.e. number of rows to be pulled at once (default:0 means all results are pulled in directly)
  - driver
```
protected Driver driver
```
    The Driver registered for this database instance TODO: it may be more reasonable to share the same driver instance for all database insances of the same type...check that and adapt
  - inserters
```
protected List<Database.Inserter> inserters
```
    Holds all active inserters to close them in the end
  - java2SQL
```
public Map<Class<?>,SQLType> java2SQL
```
    The mapping from Java to SQL
  - type2SQL
```
public Map<Integer,SQLType> type2SQL
```
    The mapping from type codes (as defined in java.sql.Types) to SQL
  - MINCOLUMNWIDTH
```
public static final int MINCOLUMNWIDTH
```
    The minal column width for describe()
    
    See Also:
    
    Constant Field Values
  - SCREENWIDTH
```
public static final int SCREENWIDTH
```
    The screen width for describe()
    
    See Also:
    
    Constant Field Values
- Constructor Detail
  - Database
```
public Database()
```
- Method Detail
  - getConnection
```
public Connection getConnection()
```
    Returns the connection
  - reconnect
```
public void reconnect()
               throws SQLException
```
    (re-)connects to the database specified
    
    Throws:
    
    SQLException
  - connect
```
public abstract void connect()
                      throws SQLException
```
    connects to the database specified
    
    Throws:
    
    SQLException
  - close
```
public static void close(Connection connection)
```
    Closes a connection
  - close
```
public static void close(Statement statement)
```
    Closes a statement
  - close
```
public static void close(ResultSet rs)
```
    Closes a result set
  - close
```
public void close()
```
    Closes the connection
  - flush
```
public void flush()
           throws SQLException
```
    Flush the connection
    
    Throws:
    
    SQLException
  - finalize
```
public void finalize()
```
    Closes the connection
    
    Overrides:
    
    finalize in class Object
  - jarAvailable
```
public boolean jarAvailable()
```
    TRUE if the required JAR is there
  - isAutoReconnectingOnSelect
```
public boolean isAutoReconnectingOnSelect()
```
    indicates whether automatic reconnection and requerying is attempted when a broken connection is discovered after an informative (SELECT) query if this is set to false, a ConnectionBrokenSQLException is thrown instead
  - setAutoReconnectOnSelect
```
public void setAutoReconnectOnSelect(boolean autoReconnectOnSelect)
```
    enable/disable automatic reconnection and requerying when a broken connection is discovered after an informative (SELECT) query if this is set to false, a ConnectionBrokenSQLException is thrown instead
  - isAutoReconnectingOnUpdate
```
public boolean isAutoReconnectingOnUpdate()
```
    indicates whether automatic reconnection and requerying is attempted when a broken connection is discovered after an update (INSERT, UPDATE) query if this is set to false, a ConnectionBrokenSQLException is thrown instead Note: In rare cases this may lead to an update query being executed twice, so treat with care!
  - setAutoReconnectOnUpdate
```
public void setAutoReconnectOnUpdate(boolean autoReconnectOnUpdate)
```
    enables/disables whether automatic reconnection and requerying is attempted when a broken connection is discovered after an update (INSERT, UPDATE) query if this is set to false, a ConnectionBrokenSQLException is thrown instead Note: In rare cases this may lead to an update query being executed twice, so treat with care!
  - getFetchsize
```
public int getFetchsize()
```
    gets the current default fetchsize affecting all queries where no specific fetchsize is provided as query argument The fetchsize determines how many result rows are pulled in from the server at once. Note: Not all database drivers may implement this properly/in a way supported by this class
  - setFetchsize
```
public void setFetchsize(int fetchsize)
```
    sets the default fetchsize affecting all following queries where no specific fetchsize is provided as query argument The fetchsize determines how many result rows are pulled in from the server at once. Note: Not all database drivers may implement this properly/in a way supported by this class e.g. for Postgre this has only an effect when using transactions
  - getValidityCheckTimeout
```
public int getValidityCheckTimeout()
```
    time in milliseconds after which a connection is considered broken when no answer is received within that time frame
  - setValidityCheckTimeout
```
public void setValidityCheckTimeout(int validityCheckTimeout)
```
    sets the amount of time a database has to answer to a connection probing before the connection is considered broken Note: the value cannot be smaller than 0
  - prepareQuery
```
protected String prepareQuery(String sql)
```
    Prepares the query internally for a call (e.g. adds a semicolon). This implementation does nothing
  - getResultSetConcurrency
```
public int getResultSetConcurrency()
```
    Returns the resultSetConcurrency
  - setResultSetConcurrency
```
public void setResultSetConcurrency(int resultSetConcurrency)
```
    Sets the resultSetConcurrency
  - getResultSetType
```
public int getResultSetType()
```
    Returns the resultSetType
  - setResultSetType
```
public void setResultSetType(int resultSetType)
```
    Sets the resultSetType
  - connected
```
public boolean connected()
```
    Checks whether the connection to the database is still alive
  - attemptReconnect
```
protected void attemptReconnect(SQLException cause,
                                boolean autoReconnect)
                         throws SQLException
```
    called when query execution failed due to some exception; checks connectivity and if connection is broken may attempt to reconnect depending on the given parameters, if the connection is still alive, reconnection fails or autoReconnect is not enabled throws a fitting exception
    
    Throws:
    
    SQLException
  - executeQuery
```
protected ResultSet executeQuery(String sql,
                                 int resultSetType,
                                 int resultSetConcurrency,
                                 Integer fetchsize)
                          throws SQLException
```
    Returns the results for a query as a ResultSet with given type, concurrency and fetchsize. Does not check whether query is an update or select query! The preferred way to execute a query is by the query(String, ResultIterator) method, because it ensures that the statement is closed afterwards. External code should always call one of the 'query' or the 'executeUpdate' methods.
    
    Throws:
    
    SQLException
  - query
```
public ResultSet query(CharSequence sqlcs,
                       int resultSetType,
                       int resultSetConcurrency,
                       Integer fetchsize)
                throws SQLException
```
    Returns the results for a query as a ResultSet with given type, concurrency and fetchsize. The preferred way to execute a query is by the query(String, ResultIterator) method, because it ensures that the statement is closed afterwards. If the query is an update query (i.e. INSERT/DELETE/UPDATE) the method calls executeUpdate and returns null. The preferred way to execute an update query is via the executeUpdate method, because it does not create an open statement.
    
    Throws:
    
    SQLException
  - query
```
public ResultSet query(CharSequence sqlcs,
                       int resultSetType,
                       int resultSetConcurrency)
                throws SQLException
```
    Returns the results for a query as a ResultSet with given type and concurrency. The preferred way to execute a query is by the query(String, ResultIterator) method, because it ensures that the statement is closed afterwards. If the query is an update query (i.e. INSERT/DELETE/UPDATE) the method calls executeUpdate and returns null. The preferred way to execute an update query is via the executeUpdate method, because it does not create an open statement.
    
    Throws:
    
    SQLException
  - query
```
public ResultSet query(CharSequence sql)
                throws SQLException
```
    Returns the results for a query as a ResultSet with default type and concurrency (read comments!). The preferred way to execute a query is by the query(String, ResultWrapper) method, because it ensures that the statement is closed afterwards. If you use the query(String) method instead, be sure to call Database.close(ResultSet) on the result set, because this ensures that the underlying statement is closed. The preferred way to execute an update query (i.e. INSERT/DELETE/UPDATE) is via the executeUpdate method, because it does not create an open statement. If query(String) is called with an update query, this method calls executeUpdate automatically and returns null.
    
    Throws:
    
    SQLException
  - executeUpdate
```
public int executeUpdate(CharSequence sqlcs)
                  throws SQLException
```
    Executes an SQL update query, returns the number of rows added/deleted
    
    Throws:
    
    SQLException
  - executeUpdateQuery
```
protected int executeUpdateQuery(String sqlcs)
                          throws SQLException
```
    Executes an SQL update query, returns the number of rows added/deleted
    
    Throws:
    
    SQLException
  - query
```
public <T> ResultIterator<T> query(CharSequence sql,
                                   ResultIterator.ResultWrapper<T> rc)
                            throws SQLException
```
    Returns the results for a query as a ResultIterator
    
    Throws:
    
    SQLException
  - queryValue
```
public <T> T queryValue(CharSequence sql,
                        ResultIterator.ResultWrapper<T> rc)
                 throws SQLException
```
    Returns a single value (or null)
    
    Throws:
    
    SQLException
  - exists
```
public boolean exists(CharSequence sql)
               throws SQLException
```
    Returns TRUE if the resultset is not empty
    
    Throws:
    
    SQLException
  - startTransaction
```
public void startTransaction()
                      throws Database.InitTransactionSQLException
```
    Initiates a transaction by disabling autocommit and enabling transaction mode
    
    Throws:
    
    Database.InitTransactionSQLException
  - commitTransaction
```
protected void commitTransaction()
                          throws Database.TransactionSQLException
```
    commits the transaction aggregated so far if the commit fails the transaction is rolled back!
    
    Throws:
    
    Database.TransactionSQLException
  - resetTransaction
```
public void resetTransaction()
                      throws Database.TransactionSQLException
```
    resets the transaction rolling it back and closing it
    
    Throws:
    
    Database.TransactionSQLException
  - endTransaction
```
public void endTransaction()
                    throws Database.TransactionSQLException
```
    executes the transaction and switches back from transaction mode into autocommit mode
    
    Throws:
    
    Database.TransactionSQLException
  - endTransaction
```
@Deprecated
public void endTransaction(@Deprecated
                                       boolean flush)
                                throws Database.TransactionSQLException
```
    Deprecated.
    
    Please use the version without parameter
    
    Parameters:
    
    flush - deprecated, will be removed Note: The flush parameter is deprecated and will be removed as the transaction end always requires a commit
    
    Throws:
    
    Database.TransactionSQLException
  - lockTableWriteAccess
```
public void lockTableWriteAccess(Map<String,String> tableAndAliases)
                          throws SQLException
```
    Locks a table in write mode, i.e. other db connections can only read the table, but not write to it
    
    Throws:
    
    SQLException
  - lockTableReadAccess
```
public void lockTableReadAccess(Map<String,String> tableAndAliases)
                         throws SQLException
```
    Locks a table in read mode, i.e. only this connection can read or write the table
    
    Throws:
    
    SQLException
  - releaseLocksAndEndTransaction
```
public void releaseLocksAndEndTransaction()
                                   throws SQLException
```
    releases all locks the connection holds, commits the current transaction and ends it
    
    Throws:
    
    SQLException
  - appendFixedLen
```
protected static void appendFixedLen(StringBuilder b,
                                     Object o,
                                     int len)
```
    Appends something to a StringBuilder with a fixed length
  - describe
```
public static String describe(ResultSet r,
                              int maxrows)
                       throws SQLException
```
    Returns a String-representation of a ResultSet, maximally maxrows rows (or all for -1)
    
    Throws:
    
    SQLException
  - describe
```
public static String describe(ResultSet r)
                       throws SQLException
```
    Returns a String-representation of a ResultSet
    
    Throws:
    
    SQLException
  - getSQLType
```
public SQLType getSQLType(int t)
```
    Returns an SQLType for the given Type as defined in java.sql.Types
  - getSQLType
```
public SQLType getSQLType(int t,
                          int scale)
```
    Returns an SQLType for the given Type as defined in java.sql.Types with a scale
  - getSQLType
```
public SQLType getSQLType(Class<?> c)
```
    Returns an SQLType for the given class
  - getSQLStmntIFNULL
```
public String getSQLStmntIFNULL(String a,
                                String b)
```
    returns the database system specific expression for if-null functionality i.e. ifnull(a,b) returns b if a is null and a otherwise
  - format
```
public String format(Object o)
```
    Formats an object appropriately (provided that its class is in java2SQL)
  - formatNullToNull
```
public String formatNullToNull(Object o)
```
    Formats an object appropriately (provided that its class is in java2SQL) and assigns NULL if the given object is a null pointer
  - cast
```
public String cast(String value,
                   String type)
```
    Produces an SQL fragment casting the given value to the given type *
  - limit
```
public String limit(String sql,
                    int n)
```
    Makes an SQL query limited to n results
  - offset
```
public String offset(String sql,
                     int n)
```
    Makes sure a query response starts at the n-th result
  - autoincrementColumn
```
public String autoincrementColumn()
```
    Produces an SQL fragment representing an autoincrementing column type s.t. if used during table creation a column can be declared to get by default an integer value assigned according to an internal sequence counter Example: createTable("tableWithSingleAutoIncrementingIDColumn", "ID", autoincrementColumn())
  - createTable
```
public void createTable(String name,
                        Object... attributes)
                 throws SQLException
```
    Creates or rewrites an SQL table. Attributes is an alternating sequence of a name (String) and a type (from java.sql.Type).
    
    Throws:
    
    SQLException
  - existsTable
```
public boolean existsTable(String table)
```
    checks if a table with the given name exists (or rather whether it can be accessed).
    
    Parameters:
    
    table - name of the table to be checked Note: if there is any error with the database connection, the function will also return false.
  - indexName
```
public String indexName(String table,
                        String... attributes)
```
    Creates an index name
  - createIndexCommand
```
public String createIndexCommand(String table,
                                 boolean unique,
                                 String... attributes)
```
    Returns the command to create one index on a table
  - createIndex
```
public void createIndex(String table,
                        boolean unique,
                        String... attributes)
                 throws SQLException
```
    Throws:
    
    SQLException
  - createIndices
```
public void createIndices(String table,
                          String... attributes)
                   throws SQLException
```
    Creates non-unique single indices on a table
    
    Throws:
    
    SQLException
  - createPrimaryKey
```
public void createPrimaryKey(String table,
                             String... attributes)
                      throws SQLException
```
    makes the given attributes/columns the primary key of the given table
    
    Throws:
    
    SQLException
  - createView
```
public void createView(String name,
                       String query)
                throws SQLException
```
    creates a view with given name over the query
    
    Throws:
    
    SQLException
  - makeCSV
```
public void makeCSV(String table,
                    File output,
                    char separator)
             throws IOException,
                    SQLException
```
    Produces a CSV version of the table
    
    Throws:
    
    IOException
    
    SQLException
  - dumpCSV
```
public void dumpCSV(String table,
                    File output,
                    char separator)
             throws IOException,
                    SQLException
```
    Produces a CSV version of the table
    
    Throws:
    
    IOException
    
    SQLException
  - makeCSVForQuery
```
public void makeCSVForQuery(String selectCommand,
                            File output,
                            char separator)
                     throws IOException,
                            SQLException
```
    Produces a CSV version of the query
    
    Throws:
    
    IOException
    
    SQLException
  - dumpQueryAsCSV
```
public void dumpQueryAsCSV(String selectCommand,
                           File output,
                           char separator)
                    throws IOException,
                           SQLException
```
    Produces a CSV version of the query
    
    Throws:
    
    IOException
    
    SQLException
  - loadCSV
```
public void loadCSV(String table,
                    File input,
                    boolean clearTable,
                    char separator)
             throws IOException,
                    SQLException
```
    Loads a CSV file into a table
    
    Throws:
    
    IOException
    
    SQLException
  - toString
```
public String toString()
```
    Misc. ****
    
    Overrides:
    
    toString in class Object
  - runInterface
```
public void runInterface()
```
    Runs a user-interface and closes
  - main
```
public static void main(String[] args)
                 throws Exception
```
    Test routine
    
    Throws:
    
    Exception
  - newInserter
```
public Database.Inserter newInserter(String table)
                              throws SQLException
```
    Returns an inserter for a table with specific column types
    
    Throws:
    
    SQLException
  - newInserter
```
public Database.Inserter newInserter(String table,
                                     Class<?>... argumentTypes)
                              throws SQLException
```
    Returns an inserter for a table with specific column types
    
    Throws:
    
    SQLException
  - newInserter
```
public Database.Inserter newInserter(String table,
                                     int... argumentTypes)
                              throws SQLException
```
    Returns an inserter for a table with specific column types given as java.sql.Type constants
    
    Throws:
    
    SQLException

Class Database

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

connection

description

resultSetType

resultSetConcurrency

fetchsize

driver

inserters

java2SQL

type2SQL

MINCOLUMNWIDTH

SCREENWIDTH

Constructor Detail

Database

Method Detail

getConnection

reconnect

connect

close

close

close

close

flush

finalize

jarAvailable

isAutoReconnectingOnSelect

setAutoReconnectOnSelect

isAutoReconnectingOnUpdate

setAutoReconnectOnUpdate

getFetchsize

setFetchsize

getValidityCheckTimeout

setValidityCheckTimeout

prepareQuery

getResultSetConcurrency

setResultSetConcurrency

getResultSetType

setResultSetType

connected

attemptReconnect

executeQuery

query

query

query

executeUpdate

executeUpdateQuery

query

queryValue

exists

startTransaction

commitTransaction

resetTransaction

endTransaction

endTransaction

lockTableWriteAccess

lockTableReadAccess

releaseLocksAndEndTransaction

appendFixedLen

describe

describe

getSQLType

getSQLType

getSQLType

getSQLStmntIFNULL

format

formatNullToNull

cast

limit

offset

autoincrementColumn

createTable

existsTable

indexName

createIndexCommand