Base (JavaLite - Java, light as a feather 2.5-j8-SNAPSHOT API)

java.lang.Object
- org.javalite.activejdbc.Base

```
public class Base
extends Object
```
This class provides a number of convenience methods for opening/closing database connections, running various types of queries, and executing SQL statements. This class differs from DB such that in this class you a logical name for a connection is hard-coded to be "default". Use this class when you have only one database.
This class is a convenience wrapper of DB

Author:

Igor Polevoy, Eric Nielsen

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static void`	`addBatch(PreparedStatement ps, Object... parameters)` Adds a batch statement using given `java.sql.PreparedStatement` and parameters.
`static void`	`attach(Connection connection)` Attaches a database connection to current thread under a default name.
`static void`	`close()` Closes connection and detaches it from current thread.
`static void`	`close(boolean suppressWarning)` Closes connection and detaches it from current thread.
`static void`	`closePreparedStatement(PreparedStatement ps)` Quietly closes the `java.sql.PreparedStatement` used in a batch execution.
`static void`	`commitTransaction()` Commits local transaction.
`static Connection`	`connection()` Returns connection attached to a current thread and named "default".
`static Long`	`count(String table)` Returns count of rows in table.
`static Long`	`count(String table, String query, Object... params)` Runs a count query, returns a number of matching records.
`static Connection`	`detach()` Detaches a default connection from current thread and returns an instance of it.
`static int`	`exec(String query)` Executes DML.
`static int`	`exec(String query, Object... params)` Executes parametrized DML - will contain question marks as placeholders.
`static int[]`	`executeBatch(PreparedStatement ps)` Executes a batch on `java.sql.PreparedStatement`.
`static RowProcessor`	`find(RowProcessor.ResultSetType type, RowProcessor.ResultSetConcur concur, int fetchSize, String query, Object... params)` Executes a raw query and returns an instance of `RowProcessor`.
`static RowProcessor`	`find(String query, Object... params)` Executes a raw query and returns an instance of `RowProcessor`.
`static void`	`find(String sql, RowListener listener)` Executes a raw query and calls instance of `RowListener` with every row found.
`static List<Map>`	`findAll(String query)` This method returns entire resultset as one list.
`static List<Map>`	`findAll(String query, Object... params)` This method returns entire resultset as one list.
`static Object`	`firstCell(String query, Object... params)` Returns a value of the first column of the first row.
`static List`	`firstColumn(String query, Object... params)` This method returns entire resultset as one list.
`static boolean`	`hasConnection()` Use to check if there is a default connection present on current thread.
`static DB`	`open()` This method will open a connection defined in the file 'database.properties' set by an initial previous call to `DBConfiguration.loadConfiguration(String)`.
`static DB`	`open(DataSource dataSource)` Opens a connection from a datasource.
`static DB`	`open(String jndiName)` Opens a connection from JNDI based on a registered name.
`static DB`	`open(String jndiName, Properties jndiProperties)` Opens a new connection from JNDI data source by name using explicit JNDI properties.
`static DB`	`open(String driver, String url, Properties props)` Opens a new connection in case additional driver-specific parameters need to be passed in.
`static DB`	`open(String driver, String url, String user, String password)` Opens a new connection based on JDBC properties and attaches it to a current thread.
`static void`	`openTransaction()` Opens local transaction.
`static void`	`rollbackTransaction()` Rolls back local transaction.
`static PreparedStatement`	`startBatch(String parametrizedStatement)` Creates a `java.sql.PreparedStatement` to be used in batch executions later.
`static <T> T`	`withDb(DataSource dataSource, Supplier<T> supplier)` Same as `DB.withDb(DataSource, Supplier)`, but with db name `DB.DEFAULT_NAME`.
`static <T> T`	`withDb(String jndiName, Properties jndiProperties, Supplier<T> supplier)` Same as `DB.withDb(String, Properties, Supplier)`, but with db name `DB.DEFAULT_NAME`.
`static <T> T`	`withDb(String driver, String url, Properties properties, Supplier<T> supplier)` Same as `DB.withDb(String, Properties, Supplier)`, but with db name `DB.DEFAULT_NAME`.
`static <T> T`	`withDb(String driver, String url, String user, String password, Supplier<T> supplier)` Same as `DB.withDb(String, String, String, String, Supplier)`, but with db name `DB.DEFAULT_NAME`.
`static <T> T`	`withDb(String jndiName, Supplier<T> supplier)` Same as `DB.withDb(String, Supplier)`, but with db name `DB.DEFAULT_NAME`.
`static <T> T`	`withDb(Supplier<T> supplier)` Same as `DB.withDb(Supplier)`, but with db name `DB.DEFAULT_NAME`.

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

- Method Detail
  - open
```
public static DB open()
```
    This method will open a connection defined in the file 'database.properties' set by an initial previous call to DBConfiguration.loadConfiguration(String). The connection picked up from the file is defined by ACTIVE_ENV environment variable or active_env system property. If this variable is not defined, it defaults to 'development' environment. If there is JUnit on classpath, this method assumes it is running under test, and defaults to 'test'.
  - open
```
public static DB open(String driver,
                      String url,
                      String user,
                      String password)
```
    Opens a new connection based on JDBC properties and attaches it to a current thread.
    
    Parameters:
    
    driver - class name of driver
    
    url - URL connection to DB
    
    user - user name.
    
    password - password.
  - open
```
public static DB open(String driver,
                      String url,
                      Properties props)
```
    Opens a new connection in case additional driver-specific parameters need to be passed in.
    
    Parameters:
    
    driver - driver class name
    
    url - JDBC URL
    
    props - connection properties
  - open
```
public static DB open(String jndiName)
```
    Opens a connection from JNDI based on a registered name. This assumes that there is a jndi.properties file with proper JNDI configuration in it.
    
    Parameters:
    
    jndiName - name of a configured data source.
  - open
```
public static DB open(String jndiName,
                      Properties jndiProperties)
```
    Opens a new connection from JNDI data source by name using explicit JNDI properties. This method can be used in cases when file jndi.properties cannot be easily modified.
    
    Parameters:
    
    jndiName - name of JNDI data source.
    
    jndiProperties - JNDI properties
  - open
```
public static DB open(DataSource dataSource)
```
    Opens a connection from a datasource. This methods gives a high level control while sourcing a DB connection.
    
    Parameters:
    
    dataSource - datasource will be used to acquire a connection.
  - connection
```
public static Connection connection()
```
    Returns connection attached to a current thread and named "default".
    
    Returns:
    
    connection attached to a current thread and named "default".
  - hasConnection
```
public static boolean hasConnection()
```
    Use to check if there is a default connection present on current thread.
    
    Returns:
    
    true if finds default connection on current thread, false if not.
  - close
```
public static void close(boolean suppressWarning)
```
    Closes connection and detaches it from current thread.
    
    Parameters:
    
    suppressWarning - true to not display a warning in case of a problem (connection not there)
  - close
```
public static void close()
```
    Closes connection and detaches it from current thread.
  - count
```
public static Long count(String table)
```
    Returns count of rows in table.
    
    Parameters:
    
    table - name of table.
    
    Returns:
    
    count of rows in table.
  - count
```
public static Long count(String table,
                         String query,
                         Object... params)
```
    Runs a count query, returns a number of matching records.
    
    Parameters:
    
    table - table in which to count rows.
    
    query - this is a filtering query for the count. If '*' provided, all records will be counted. Example: "age > 65 AND department = 'accounting'"
    
    params - parameters for placeholder substitution.
    
    Returns:
    
    copunt number of records found in a table.
  - firstCell
```
public static Object firstCell(String query,
                               Object... params)
```
    Returns a value of the first column of the first row. This query expects only one column selected in the select statement. If more than one column returned, it will throw IllegalArgumentException.
    
    Parameters:
    
    query - query
    
    params - parameters
    
    Returns:
    
    fetched value, or null if query did not fetch anything.
  - findAll
```
public static List<Map> findAll(String query,
                                Object... params)
```
    This method returns entire resultset as one list. Do not use it for large result sets. Example:
```
 List<Map> people = Base.findAll("select * from people where first_name = ?", "John");
 for (Map person : people)
     System.out.println(person.get("first_name"));
 
```
    Parameters:
    
    query - raw SQL query. This query is parametrized.
    
    params - list of parameters for a parametrized query.
    
    Returns:
    
    entire result set corresponding to the query.
  - firstColumn
```
public static List firstColumn(String query,
                               Object... params)
```
    This method returns entire resultset as one list. Do not use it for large result sets. Example:
```
  List ssns = Base.firstColumn("select ssn from people where first_name = ?", "John");
  for(Object ssn: ssns)
      System.out.println(ssn);
 
```
    This methods expects a query which selects only one column from a table/view. It will throw an exception if more than one columns are fetched in a result set.
    Parameters:
    
    query - raw SQL query. This query is parametrized.
    
    params - list of parameters for a parametrized query.
    
    Returns:
    
    entire result set corresponding to the query.
  - findAll
```
public static List<Map> findAll(String query)
```
    This method returns entire resultset as one list. Do not use it for large result sets.
    
    Parameters:
    
    query - raw SQL query. This query is not parametrized.
    
    Returns:
    
    entire result set corresponding to the query.
  - find
```
public static RowProcessor find(String query,
                                Object... params)
```
    Executes a raw query and returns an instance of RowProcessor. Use it in the following pattern:
```
 Base.find("select first_name, last_name from really_large_table").with(new RowListenerAdapter() {
            public void onNext(Map row) {
                ///write your code here
                Object o1 = row.get("first_name");
                Object o2 = row.get("last_name");
            }
        });
     
```
    Parameters:
    
    query - raw SQL.
    
    params - list of parameters if query is parametrized.
    
    Returns:
    
    instance of RowProcessor which has with() method for convenience.
  - find
```
public static RowProcessor find(RowProcessor.ResultSetType type,
                                RowProcessor.ResultSetConcur concur,
                                int fetchSize,
                                String query,
                                Object... params)
```
    Executes a raw query and returns an instance of RowProcessor. Use it in the following pattern:
```
   Base.find("select first_name, last_name from really_large_table", ....).with(new RowListenerAdapter() {
     public void onNext(Map row) {
     ///write your code here
     Object o1 = row.get("first_name");
     Object o2 = row.get("last_name");
     }
     });
     
```
    See ResultSet Docs
    Parameters:
    
    query - raw SQL.
    
    type - type of result set
    
    concur - concurrent mode of result set
    
    fetchSize - size of result set
    
    params - list of parameters if query is parametrized.
    
    Returns:
    
    instance of RowProcessor which has with() method for convenience.
  - find
```
public static void find(String sql,
                        RowListener listener)
```
    Executes a raw query and calls instance of RowListener with every row found. Use this method for very large result sets.
    
    Parameters:
    
    sql - raw SQL query.
    
    listener - client listener implementation for processing individual rows.
  - exec
```
public static int exec(String query)
```
    Executes DML. Use it for inserts and updates.
    
    Parameters:
    
    query - raw DML.
    
    Returns:
    
    number of rows afected by query.
  - exec
```
public static int exec(String query,
                       Object... params)
```
    Executes parametrized DML - will contain question marks as placeholders.
    
    Parameters:
    
    query - query to execute - will contain question marks as placeholders.
    
    params - query parameters.
    
    Returns:
    
    number of records affected.
  - openTransaction
```
public static void openTransaction()
```
    Opens local transaction.
  - commitTransaction
```
public static void commitTransaction()
```
    Commits local transaction.
  - rollbackTransaction
```
public static void rollbackTransaction()
```
    Rolls back local transaction.
  - startBatch
```
public static PreparedStatement startBatch(String parametrizedStatement)
```
    Creates a java.sql.PreparedStatement to be used in batch executions later.
    
    Parameters:
    
    parametrizedStatement - Example of a statement: INSERT INTO employees VALUES (?, ?).
    
    Returns:
    
    instance of java.sql.PreparedStatement with compiled query.
  - addBatch
```
public static void addBatch(PreparedStatement ps,
                            Object... parameters)
```
    Adds a batch statement using given java.sql.PreparedStatement and parameters.
    
    Parameters:
    
    ps - java.sql.PreparedStatement to add batch to.
    
    parameters - parameters for the query in java.sql.PreparedStatement. Parameters will be set on the statement in the same order as provided here.
  - executeBatch
```
public static int[] executeBatch(PreparedStatement ps)
```
    Executes a batch on java.sql.PreparedStatement.
    
    Parameters:
    
    ps - java.sql.PreparedStatement to execute batch on.
    
    Returns:
    
    an array of update counts containing one element for each command in the batch. The elements of the array are ordered according to the order in which commands were added to the batch.
    
    See Also:
    
    Statement#executeBatch()
  - closePreparedStatement
```
public static void closePreparedStatement(PreparedStatement ps)
```
    Quietly closes the java.sql.PreparedStatement used in a batch execution. The advantage over calling java.sql.PreparedStatement.close() directly is not having to explicitly handle a checked exception (java.sql.SQLException). This method should typically be called in a finally block. So as not to displace any exception (e.g. from a failed batch execution) that might already be in flight, this method swallows any exception that might arise from closing the statement. This is generally seen as a worthwhile trade-off, as it much less likely for a close to fail without a prior failure.
    
    Parameters:
    
    ps - java.sql.PreparedStatement with which a batch has been executed. If null, this is a no-op.
  - attach
```
public static void attach(Connection connection)
```
    Attaches a database connection to current thread under a default name.
    
    Parameters:
    
    connection - instance of connection to attach to current thread.
  - detach
```
public static Connection detach()
```
    Detaches a default connection from current thread and returns an instance of it. This method does not close a connection. Use it for cases of advanced connection management, such as integration with Spring Framework.
    
    Returns:
    
    instance of a default connection detached from current thread by name passed to constructor.
  - withDb
```
public static <T> T withDb(String jndiName,
                           Properties jndiProperties,
                           Supplier<T> supplier)
```
    Same as DB.withDb(String, Properties, Supplier), but with db name DB.DEFAULT_NAME.
  - withDb
```
public static <T> T withDb(DataSource dataSource,
                           Supplier<T> supplier)
```
    Same as DB.withDb(DataSource, Supplier), but with db name DB.DEFAULT_NAME.
  - withDb
```
public static <T> T withDb(String jndiName,
                           Supplier<T> supplier)
```
    Same as DB.withDb(String, Supplier), but with db name DB.DEFAULT_NAME.
  - withDb
```
public static <T> T withDb(String driver,
                           String url,
                           Properties properties,
                           Supplier<T> supplier)
```
    Same as DB.withDb(String, Properties, Supplier), but with db name DB.DEFAULT_NAME.
  - withDb
```
public static <T> T withDb(String driver,
                           String url,
                           String user,
                           String password,
                           Supplier<T> supplier)
```
    Same as DB.withDb(String, String, String, String, Supplier), but with db name DB.DEFAULT_NAME.
  - withDb
```
public static <T> T withDb(Supplier<T> supplier)
```
    Same as DB.withDb(Supplier), but with db name DB.DEFAULT_NAME.

Class Base

Method Summary

Methods inherited from class java.lang.Object

Method Detail

open

open

open

open

open

open

connection

hasConnection

close

close

count

count

firstCell

findAll

firstColumn

findAll

find

find

find

exec

exec

openTransaction

commitTransaction

rollbackTransaction

startBatch

addBatch

executeBatch

closePreparedStatement

attach

detach

withDb

withDb

withDb

withDb

withDb

withDb