Operator (core API)

java.lang.Object
- org.litepal.Operator

```
public class Operator
extends java.lang.Object
```
LitePal is an Android library that allows developers to use SQLite database extremely easy. You can initialized it by calling initialize(Context) method to make LitePal ready to work. Also you can switch the using database by calling use(LitePalDB) and useDefault() methods.

从以下版本开始:

2.1

构造器概要

构造器
构造器和说明

Operator()

构造器
构造器和说明
`Operator()`

方法概要

所有方法静态方法具体方法已过时的方法
限定符和类型	方法和说明
`static void`	`aesKey(java.lang.String key)`
`static double`	`average(java.lang.Class<?> modelClass, java.lang.String column)` Calculates the average value on a given column.
`static double`	`average(java.lang.String tableName, java.lang.String column)` Calculates the average value on a given column.
`static AverageExecutor`	`averageAsync(java.lang.Class<?> modelClass, java.lang.String column)` 已过时。
`static AverageExecutor`	`averageAsync(java.lang.String tableName, java.lang.String column)` 已过时。
`static void`	`beginTransaction()` Begins a transaction in EXCLUSIVE mode.
`static int`	`count(java.lang.Class<?> modelClass)` Count the records.
`static int`	`count(java.lang.String tableName)` Count the records.
`static CountExecutor`	`countAsync(java.lang.Class<?> modelClass)` 已过时。
`static CountExecutor`	`countAsync(java.lang.String tableName)` 已过时。
`static int`	`delete(java.lang.Class<?> modelClass, long id)` Deletes the record in the database by id.
`static int`	`deleteAll(java.lang.Class<?> modelClass, java.lang.String... conditions)` Deletes all records with details given if they match a set of conditions supplied.
`static int`	`deleteAll(java.lang.String tableName, java.lang.String... conditions)` Deletes all records with details given if they match a set of conditions supplied.
`static UpdateOrDeleteExecutor`	`deleteAllAsync(java.lang.Class<?> modelClass, java.lang.String... conditions)` 已过时。
`static UpdateOrDeleteExecutor`	`deleteAllAsync(java.lang.String tableName, java.lang.String... conditions)` 已过时。
`static UpdateOrDeleteExecutor`	`deleteAsync(java.lang.Class<?> modelClass, long id)` 已过时。
`static boolean`	`deleteDatabase(java.lang.String dbName)` Delete the specified database.
`static void`	`endTransaction()` End a transaction.
`static <T> T`	`find(java.lang.Class<T> modelClass, long id)` Finds the record by a specific id.
`static <T> T`	`find(java.lang.Class<T> modelClass, long id, boolean isEager)` It is mostly same as `find(Class, long)` but an isEager parameter.
`static <T> java.util.List<T>`	`findAll(java.lang.Class<T> modelClass, boolean isEager, long... ids)` It is mostly same as `findAll(Class, long...)` but an isEager parameter.
`static <T> java.util.List<T>`	`findAll(java.lang.Class<T> modelClass, long... ids)` Finds multiple records by an id array.
`static <T> FindMultiExecutor<T>`	`findAllAsync(java.lang.Class<T> modelClass, boolean isEager, long... ids)` 已过时。
`static <T> FindMultiExecutor<T>`	`findAllAsync(java.lang.Class<T> modelClass, long... ids)` 已过时。
`static <T> FindExecutor<T>`	`findAsync(java.lang.Class<T> modelClass, long id)` 已过时。
`static <T> FindExecutor<T>`	`findAsync(java.lang.Class<T> modelClass, long id, boolean isEager)` 已过时。
`static android.database.Cursor`	`findBySQL(java.lang.String... sql)` Runs the provided SQL and returns a Cursor over the result set.
`static <T> T`	`findFirst(java.lang.Class<T> modelClass)` Finds the first record of a single table.
`static <T> T`	`findFirst(java.lang.Class<T> modelClass, boolean isEager)` It is mostly same as `findFirst(Class)` but an isEager parameter.
`static <T> FindExecutor<T>`	`findFirstAsync(java.lang.Class<T> modelClass)` 已过时。
`static <T> FindExecutor<T>`	`findFirstAsync(java.lang.Class<T> modelClass, boolean isEager)` 已过时。
`static <T> T`	`findLast(java.lang.Class<T> modelClass)` Finds the last record of a single table.
`static <T> T`	`findLast(java.lang.Class<T> modelClass, boolean isEager)` It is mostly same as `findLast(Class)` but an isEager parameter.
`static <T> FindExecutor<T>`	`findLastAsync(java.lang.Class<T> modelClass)` 已过时。
`static <T> FindExecutor<T>`	`findLastAsync(java.lang.Class<T> modelClass, boolean isEager)` 已过时。
`static android.database.sqlite.SQLiteDatabase`	`getDatabase()` Get a writable SQLiteDatabase.
`static DatabaseListener`	`getDBListener()`
`static android.os.Handler`	`getHandler()` Get the main thread handler.
`static void`	`initialize(android.content.Context context)` Initialize to make LitePal ready to work.
`static <T> boolean`	`isExist(java.lang.Class<T> modelClass, java.lang.String... conditions)` Check if the specified conditions data already exists in the table.
`static FluentQuery`	`limit(int value)` Limits the number of rows returned by the query.
`static <T extends LitePalSupport> void`	`markAsDeleted(java.util.Collection<T> collection)` Provide a way to mark all models in collection as deleted.
`static <T> T`	`max(java.lang.Class<?> modelClass, java.lang.String columnName, java.lang.Class<T> columnType)` Calculates the maximum value on a given column.
`static <T> T`	`max(java.lang.String tableName, java.lang.String columnName, java.lang.Class<T> columnType)` Calculates the maximum value on a given column.
`static <T> FindExecutor<T>`	`maxAsync(java.lang.Class<?> modelClass, java.lang.String columnName, java.lang.Class<T> columnType)` 已过时。
`static <T> FindExecutor<T>`	`maxAsync(java.lang.String tableName, java.lang.String columnName, java.lang.Class<T> columnType)` 已过时。
`static <T> T`	`min(java.lang.Class<?> modelClass, java.lang.String columnName, java.lang.Class<T> columnType)` Calculates the minimum value on a given column.
`static <T> T`	`min(java.lang.String tableName, java.lang.String columnName, java.lang.Class<T> columnType)` Calculates the minimum value on a given column.
`static <T> FindExecutor<T>`	`minAsync(java.lang.Class<?> modelClass, java.lang.String columnName, java.lang.Class<T> columnType)` 已过时。
`static <T> FindExecutor<T>`	`minAsync(java.lang.String tableName, java.lang.String columnName, java.lang.Class<T> columnType)` 已过时。
`static FluentQuery`	`offset(int value)` Declaring the offset of rows returned by the query.
`static FluentQuery`	`order(java.lang.String column)` Declaring how to order the rows queried from table.
`static void`	`registerDatabaseListener(DatabaseListener listener)` Register a listener to listen database create and upgrade events.
`static <T extends LitePalSupport> boolean`	`saveAll(java.util.Collection<T> collection)` Saves the collection into database.
`static <T extends LitePalSupport> SaveExecutor`	`saveAllAsync(java.util.Collection<T> collection)` 已过时。
`static FluentQuery`	`select(java.lang.String... columns)` Declaring to query which columns in table.
`static void`	`setTransactionSuccessful()` Marks the current transaction as successful.
`static <T> T`	`sum(java.lang.Class<?> modelClass, java.lang.String columnName, java.lang.Class<T> columnType)` Calculates the sum of values on a given column.
`static <T> T`	`sum(java.lang.String tableName, java.lang.String columnName, java.lang.Class<T> columnType)` Calculates the sum of values on a given column.
`static <T> FindExecutor<T>`	`sumAsync(java.lang.Class<?> modelClass, java.lang.String columnName, java.lang.Class<T> columnType)` 已过时。
`static <T> FindExecutor<T>`	`sumAsync(java.lang.String tableName, java.lang.String columnName, java.lang.Class<T> columnType)` 已过时。
`static int`	`update(java.lang.Class<?> modelClass, android.content.ContentValues values, long id)` Updates the corresponding record by id with ContentValues.
`static int`	`updateAll(java.lang.Class<?> modelClass, android.content.ContentValues values, java.lang.String... conditions)` Updates all records with details given if they match a set of conditions supplied.
`static int`	`updateAll(java.lang.String tableName, android.content.ContentValues values, java.lang.String... conditions)` Updates all records with details given if they match a set of conditions supplied.
`static UpdateOrDeleteExecutor`	`updateAllAsync(java.lang.Class<?> modelClass, android.content.ContentValues values, java.lang.String... conditions)` 已过时。
`static UpdateOrDeleteExecutor`	`updateAllAsync(java.lang.String tableName, android.content.ContentValues values, java.lang.String... conditions)` 已过时。
`static UpdateOrDeleteExecutor`	`updateAsync(java.lang.Class<?> modelClass, android.content.ContentValues values, long id)` 已过时。
`static void`	`use(LitePalDB litePalDB)` Switch the using database to the one specified by parameter.
`static void`	`useDefault()` Switch the using database to default with configuration by litepal.xml.
`static FluentQuery`	`where(java.lang.String... conditions)` Declaring to query which rows in table.

从类继承的方法 java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- 构造器详细资料
  - Operator
```
public Operator()
```
- 方法详细资料
  - getHandler
```
public static android.os.Handler getHandler()
```
    Get the main thread handler. You don't need this method. It's used by framework only.
    
    返回:
    
    Main thread handler.
  - initialize
```
public static void initialize(android.content.Context context)
```
    Initialize to make LitePal ready to work. If you didn't configure LitePalApplication in the AndroidManifest.xml, make sure you call this method as soon as possible. In Application's onCreate() method will be fine.
    
    参数:
    
    context - Application context.
  - getDatabase
```
public static android.database.sqlite.SQLiteDatabase getDatabase()
```
    Get a writable SQLiteDatabase.
    
    返回:
    
    A writable SQLiteDatabase instance
  - beginTransaction
```
public static void beginTransaction()
```
    Begins a transaction in EXCLUSIVE mode.
  - endTransaction
```
public static void endTransaction()
```
    End a transaction.
  - setTransactionSuccessful
```
public static void setTransactionSuccessful()
```
    Marks the current transaction as successful. Do not do any more database work between calling this and calling endTransaction. Do as little non-database work as possible in that situation too. If any errors are encountered between this and endTransaction the transaction will still be committed.
  - use
```
public static void use(LitePalDB litePalDB)
```
    Switch the using database to the one specified by parameter.
    
    参数:
    
    litePalDB - The database to switch to.
  - useDefault
```
public static void useDefault()
```
    Switch the using database to default with configuration by litepal.xml.
  - deleteDatabase
```
public static boolean deleteDatabase(java.lang.String dbName)
```
    Delete the specified database.
    
    参数:
    
    dbName - Name of database to delete.
    
    返回:
    
    True if delete success, false otherwise.
  - aesKey
```
public static void aesKey(java.lang.String key)
```
  - select
```
public static FluentQuery select(java.lang.String... columns)
```
    Declaring to query which columns in table.
```
 LitePal.select("name", "age").find(Person.class);
 
```
    This will find all rows with name and age columns in Person table.
    参数:
    
    columns - A String array of which columns to return. Passing null will return all columns.
    
    返回:
    
    A FluentQuery instance.
  - where
```
public static FluentQuery where(java.lang.String... conditions)
```
    Declaring to query which rows in table.
```
 LitePal.where("name = ? or age > ?", "Tom", "14").find(Person.class);
 
```
    This will find rows which name is Tom or age greater than 14 in Person table.
    参数:
    
    conditions - A filter declaring which rows to return, formatted as an SQL WHERE clause. Passing null will return all rows.
    
    返回:
    
    A FluentQuery instance.
  - order
```
public static FluentQuery order(java.lang.String column)
```
    Declaring how to order the rows queried from table.
```
 LitePal.order("name desc").find(Person.class);
 
```
    This will find all rows in Person table sorted by name with inverted order.
    参数:
    
    column - How to order the rows, formatted as an SQL ORDER BY clause. Passing null will use the default sort order, which may be unordered.
    
    返回:
    
    A FluentQuery instance.
  - limit
```
public static FluentQuery limit(int value)
```
    Limits the number of rows returned by the query.
```
 LitePal.limit(2).find(Person.class);
 
```
    This will find the top 2 rows in Person table.
    参数:
    
    value - Limits the number of rows returned by the query, formatted as LIMIT clause.
    
    返回:
    
    A FluentQuery instance.
  - offset
```
public static FluentQuery offset(int value)
```
    Declaring the offset of rows returned by the query. This method must be used with limit(int), or nothing will return.
```
 LitePal.limit(1).offset(2).find(Person.class);
 
```
    This will find the third row in Person table.
    参数:
    
    value - The offset amount of rows returned by the query.
    
    返回:
    
    A FluentQuery instance.
  - count
```
public static int count(java.lang.Class<?> modelClass)
```
    Count the records.
```
 LitePal.count(Person.class);
 
```
    This will count all rows in person table.
    You can also specify a where clause when counting.
```
 LitePal.where("age > ?", "15").count(Person.class);
 
```
    参数:
    
    modelClass - Which table to query from by class.
    
    返回:
    
    Count of the specified table.
  - countAsync
```
@Deprecated
public static CountExecutor countAsync(java.lang.Class<?> modelClass)
```
    已过时。
    
    This method is deprecated and will be removed in the future releases. Handle async db operation in your own logic instead.
  - count
```
public static int count(java.lang.String tableName)
```
    Count the records.
```
 LitePal.count("person");
 
```
    This will count all rows in person table.
    You can also specify a where clause when counting.
```
 LitePal.where("age > ?", "15").count("person");
 
```
    参数:
    
    tableName - Which table to query from.
    
    返回:
    
    Count of the specified table.
  - countAsync
```
@Deprecated
public static CountExecutor countAsync(java.lang.String tableName)
```
    已过时。
    
    This method is deprecated and will be removed in the future releases. Handle async db operation in your own logic instead.
  - average
```
public static double average(java.lang.Class<?> modelClass,
                             java.lang.String column)
```
    Calculates the average value on a given column.
```
 LitePal.average(Person.class, "age");
 
```
    You can also specify a where clause when calculating.
```
 LitePal.where("age > ?", "15").average(Person.class, "age");
 
```
    参数:
    
    modelClass - Which table to query from by class.
    
    column - The based on column to calculate.
    
    返回:
    
    The average value on a given column.
  - averageAsync
```
@Deprecated
public static AverageExecutor averageAsync(java.lang.Class<?> modelClass,
                                                        java.lang.String column)
```
    已过时。
    
    This method is deprecated and will be removed in the future releases. Handle async db operation in your own logic instead.
  - average
```
public static double average(java.lang.String tableName,
                             java.lang.String column)
```
    Calculates the average value on a given column.
```
 LitePal.average("person", "age");
 
```
    You can also specify a where clause when calculating.
```
 LitePal.where("age > ?", "15").average("person", "age");
 
```
    参数:
    
    tableName - Which table to query from.
    
    column - The based on column to calculate.
    
    返回:
    
    The average value on a given column.
  - averageAsync
```
@Deprecated
public static AverageExecutor averageAsync(java.lang.String tableName,
                                                        java.lang.String column)
```
    已过时。
    
    This method is deprecated and will be removed in the future releases. Handle async db operation in your own logic instead.
  - max
```
public static <T> T max(java.lang.Class<?> modelClass,
                        java.lang.String columnName,
                        java.lang.Class<T> columnType)
```
    Calculates the maximum value on a given column. The value is returned with the same data type of the column.
```
 LitePal.max(Person.class, "age", int.class);
 
```
    You can also specify a where clause when calculating.
```
 LitePal.where("age > ?", "15").max(Person.class, "age", Integer.TYPE);
 
```
    参数:
    
    modelClass - Which table to query from by class.
    
    columnName - The based on column to calculate.
    
    columnType - The type of the based on column.
    
    返回:
    
    The maximum value on a given column.
  - maxAsync
```
@Deprecated
public static <T> FindExecutor<T> maxAsync(java.lang.Class<?> modelClass,
                                                        java.lang.String columnName,
                                                        java.lang.Class<T> columnType)
```
    已过时。
    
    This method is deprecated and will be removed in the future releases. Handle async db operation in your own logic instead.
  - max
```
public static <T> T max(java.lang.String tableName,
                        java.lang.String columnName,
                        java.lang.Class<T> columnType)
```
    Calculates the maximum value on a given column. The value is returned with the same data type of the column.
```
 LitePal.max("person", "age", int.class);
 
```
    You can also specify a where clause when calculating.
```
 LitePal.where("age > ?", "15").max("person", "age", Integer.TYPE);
 
```
    参数:
    
    tableName - Which table to query from.
    
    columnName - The based on column to calculate.
    
    columnType - The type of the based on column.
    
    返回:
    
    The maximum value on a given column.
  - maxAsync
```
@Deprecated
public static <T> FindExecutor<T> maxAsync(java.lang.String tableName,
                                                        java.lang.String columnName,
                                                        java.lang.Class<T> columnType)
```
    已过时。
    
    This method is deprecated and will be removed in the future releases. Handle async db operation in your own logic instead.
  - min
```
public static <T> T min(java.lang.Class<?> modelClass,
                        java.lang.String columnName,
                        java.lang.Class<T> columnType)
```
    Calculates the minimum value on a given column. The value is returned with the same data type of the column.
```
 LitePal.min(Person.class, "age", int.class);
 
```
    You can also specify a where clause when calculating.
```
 LitePal.where("age > ?", "15").min(Person.class, "age", Integer.TYPE);
 
```
    参数:
    
    modelClass - Which table to query from by class.
    
    columnName - The based on column to calculate.
    
    columnType - The type of the based on column.
    
    返回:
    
    The minimum value on a given column.
  - minAsync
```
@Deprecated
public static <T> FindExecutor<T> minAsync(java.lang.Class<?> modelClass,
                                                        java.lang.String columnName,
                                                        java.lang.Class<T> columnType)
```
    已过时。
    
    This method is deprecated and will be removed in the future releases. Handle async db operation in your own logic instead.
  - min
```
public static <T> T min(java.lang.String tableName,
                        java.lang.String columnName,
                        java.lang.Class<T> columnType)
```
    Calculates the minimum value on a given column. The value is returned with the same data type of the column.
```
 LitePal.min("person", "age", int.class);
 
```
    You can also specify a where clause when calculating.
```
 LitePal.where("age > ?", "15").min("person", "age", Integer.TYPE);
 
```
    参数:
    
    tableName - Which table to query from.
    
    columnName - The based on column to calculate.
    
    columnType - The type of the based on column.
    
    返回:
    
    The minimum value on a given column.
  - minAsync
```
@Deprecated
public static <T> FindExecutor<T> minAsync(java.lang.String tableName,
                                                        java.lang.String columnName,
                                                        java.lang.Class<T> columnType)
```
    已过时。
    
    This method is deprecated and will be removed in the future releases. Handle async db operation in your own logic instead.
  - sum
```
public static <T> T sum(java.lang.Class<?> modelClass,
                        java.lang.String columnName,
                        java.lang.Class<T> columnType)
```
    Calculates the sum of values on a given column. The value is returned with the same data type of the column.
```
 LitePal.sum(Person.class, "age", int.class);
 
```
    You can also specify a where clause when calculating.
```
 LitePal.where("age > ?", "15").sum(Person.class, "age", Integer.TYPE);
 
```
    参数:
    
    modelClass - Which table to query from by class.
    
    columnName - The based on column to calculate.
    
    columnType - The type of the based on column.
    
    返回:
    
    The sum value on a given column.
  - sumAsync
```
@Deprecated
public static <T> FindExecutor<T> sumAsync(java.lang.Class<?> modelClass,
                                                        java.lang.String columnName,
                                                        java.lang.Class<T> columnType)
```
    已过时。
    
    This method is deprecated and will be removed in the future releases. Handle async db operation in your own logic instead.
  - sum
```
public static <T> T sum(java.lang.String tableName,
                        java.lang.String columnName,
                        java.lang.Class<T> columnType)
```
    Calculates the sum of values on a given column. The value is returned with the same data type of the column.
```
 LitePal.sum("person", "age", int.class);
 
```
    You can also specify a where clause when calculating.
```
 LitePal.where("age > ?", "15").sum("person", "age", Integer.TYPE);
 
```
    参数:
    
    tableName - Which table to query from.
    
    columnName - The based on column to calculate.
    
    columnType - The type of the based on column.
    
    返回:
    
    The sum value on a given column.
  - sumAsync
```
@Deprecated
public static <T> FindExecutor<T> sumAsync(java.lang.String tableName,
                                                        java.lang.String columnName,
                                                        java.lang.Class<T> columnType)
```
    已过时。
    
    This method is deprecated and will be removed in the future releases. Handle async db operation in your own logic instead.
  - find
```
public static <T> T find(java.lang.Class<T> modelClass,
                         long id)
```
    Finds the record by a specific id.
```
 Person p = LitePal.find(Person.class, 1);
 
```
    The modelClass determines which table to query and the object type to return. If no record can be found, then return null.
    Note that the associated models won't be loaded by default considering the efficiency, but you can do that by using find(Class, long, boolean).
    参数:
    
    modelClass - Which table to query and the object type to return.
    
    id - Which record to query.
    
    返回:
    
    An object with found data from database, or null.
  - findAsync
```
@Deprecated
public static <T> FindExecutor<T> findAsync(java.lang.Class<T> modelClass,
                                                         long id)
```
    已过时。
    
    This method is deprecated and will be removed in the future releases. Handle async db operation in your own logic instead.
  - find
```
public static <T> T find(java.lang.Class<T> modelClass,
                         long id,
                         boolean isEager)
```
    It is mostly same as find(Class, long) but an isEager parameter. If set true the associated models will be loaded as well.
    Note that isEager will only work for one deep level relation, considering the query efficiency. You have to implement on your own if you need to load multiple deepness of relation at once.
    
    参数:
    
    modelClass - Which table to query and the object type to return.
    
    id - Which record to query.
    
    isEager - True to load the associated models, false not.
    
    返回:
    
    An object with found data from database, or null.
  - findAsync
```
@Deprecated
public static <T> FindExecutor<T> findAsync(java.lang.Class<T> modelClass,
                                                         long id,
                                                         boolean isEager)
```
    已过时。
    
    This method is deprecated and will be removed in the future releases. Handle async db operation in your own logic instead.
  - findFirst
```
public static <T> T findFirst(java.lang.Class<T> modelClass)
```
    Finds the first record of a single table.
```
 Person p = LitePal.findFirst(Person.class);
 
```
    Note that the associated models won't be loaded by default considering the efficiency, but you can do that by using findFirst(Class, boolean).
    参数:
    
    modelClass - Which table to query and the object type to return.
    
    返回:
    
    An object with data of first row, or null.
  - findFirstAsync
```
@Deprecated
public static <T> FindExecutor<T> findFirstAsync(java.lang.Class<T> modelClass)
```
    已过时。
    
    This method is deprecated and will be removed in the future releases. Handle async db operation in your own logic instead.
  - findFirst
```
public static <T> T findFirst(java.lang.Class<T> modelClass,
                              boolean isEager)
```
    It is mostly same as findFirst(Class) but an isEager parameter. If set true the associated models will be loaded as well.
    Note that isEager will only work for one deep level relation, considering the query efficiency. You have to implement on your own if you need to load multiple deepness of relation at once.
    
    参数:
    
    modelClass - Which table to query and the object type to return.
    
    isEager - True to load the associated models, false not.
    
    返回:
    
    An object with data of first row, or null.
  - findFirstAsync
```
@Deprecated
public static <T> FindExecutor<T> findFirstAsync(java.lang.Class<T> modelClass,
                                                              boolean isEager)
```
    已过时。
    
    This method is deprecated and will be removed in the future releases. Handle async db operation in your own logic instead.
  - findLast
```
public static <T> T findLast(java.lang.Class<T> modelClass)
```
    Finds the last record of a single table.
```
 Person p = LitePal.findLast(Person.class);
 
```
    Note that the associated models won't be loaded by default considering the efficiency, but you can do that by using findLast(Class, boolean).
    参数:
    
    modelClass - Which table to query and the object type to return.
    
    返回:
    
    An object with data of last row, or null.
  - findLastAsync
```
@Deprecated
public static <T> FindExecutor<T> findLastAsync(java.lang.Class<T> modelClass)
```
    已过时。
    
    This method is deprecated and will be removed in the future releases. Handle async db operation in your own logic instead.
  - findLast
```
public static <T> T findLast(java.lang.Class<T> modelClass,
                             boolean isEager)
```
    It is mostly same as findLast(Class) but an isEager parameter. If set true the associated models will be loaded as well.
    Note that isEager will only work for one deep level relation, considering the query efficiency. You have to implement on your own if you need to load multiple deepness of relation at once.
    
    参数:
    
    modelClass - Which table to query and the object type to return.
    
    isEager - True to load the associated models, false not.
    
    返回:
    
    An object with data of last row, or null.
  - findLastAsync
```
@Deprecated
public static <T> FindExecutor<T> findLastAsync(java.lang.Class<T> modelClass,
                                                             boolean isEager)
```
    已过时。
    
    This method is deprecated and will be removed in the future releases. Handle async db operation in your own logic instead.
  - findAll
```
public static <T> java.util.List<T> findAll(java.lang.Class<T> modelClass,
                                            long... ids)
```
    Finds multiple records by an id array.
```
 List<Person> people = LitePal.findAll(Person.class, 1, 2, 3);

 long[] bookIds = { 10, 18 };
 List<Book> books = LitePal.findAll(Book.class, bookIds);
 
```
    Of course you can find all records by passing nothing to the ids parameter.
```
 List<Book> allBooks = LitePal.findAll(Book.class);
 
```
    Note that the associated models won't be loaded by default considering the efficiency, but you can do that by using findAll(Class, boolean, long...). The modelClass determines which table to query and the object type to return.
    参数:
    
    modelClass - Which table to query and the object type to return as a list.
    
    ids - Which records to query. Or do not pass it to find all records.
    
    返回:
    
    An object list with found data from database, or an empty list.
  - findAllAsync
```
@Deprecated
public static <T> FindMultiExecutor<T> findAllAsync(java.lang.Class<T> modelClass,
                                                                 long... ids)
```
    已过时。
    
    This method is deprecated and will be removed in the future releases. Handle async db operation in your own logic instead.
  - findAll
```
public static <T> java.util.List<T> findAll(java.lang.Class<T> modelClass,
                                            boolean isEager,
                                            long... ids)
```
    It is mostly same as findAll(Class, long...) but an isEager parameter. If set true the associated models will be loaded as well.
    Note that isEager will only work for one deep level relation, considering the query efficiency. You have to implement on your own if you need to load multiple deepness of relation at once.
    
    参数:
    
    modelClass - Which table to query and the object type to return as a list.
    
    isEager - True to load the associated models, false not.
    
    ids - Which records to query. Or do not pass it to find all records.
    
    返回:
    
    An object list with found data from database, or an empty list.
  - findAllAsync
```
@Deprecated
public static <T> FindMultiExecutor<T> findAllAsync(java.lang.Class<T> modelClass,
                                                                 boolean isEager,
                                                                 long... ids)
```
    已过时。
    
    This method is deprecated and will be removed in the future releases. Handle async db operation in your own logic instead.
  - findBySQL
```
public static android.database.Cursor findBySQL(java.lang.String... sql)
```
    Runs the provided SQL and returns a Cursor over the result set. You may include ? in where clause in the query, which will be replaced by the second to the last parameters, such as:
```
 Cursor cursor = LitePal.findBySQL("select * from person where name=? and age=?", "Tom", "14");
 
```
    参数:
    
    sql - First parameter is the SQL clause to apply. Second to the last parameters will replace the place holders.
    
    返回:
    
    A Cursor object, which is positioned before the first entry. Note that Cursors are not synchronized, see the documentation for more details.
  - delete
```
public static int delete(java.lang.Class<?> modelClass,
                         long id)
```
    Deletes the record in the database by id.
    The data in other tables which is referenced with the record will be removed too.
```
 LitePal.delete(Person.class, 1);
 
```
    This means that the record 1 in person table will be removed.
    参数:
    
    modelClass - Which table to delete from by class.
    
    id - Which record to delete.
    
    返回:
    
    The number of rows affected. Including cascade delete rows.
  - deleteAsync
```
@Deprecated
public static UpdateOrDeleteExecutor deleteAsync(java.lang.Class<?> modelClass,
                                                              long id)
```
    已过时。
    
    This method is deprecated and will be removed in the future releases. Handle async db operation in your own logic instead.
  - deleteAll
```
public static int deleteAll(java.lang.Class<?> modelClass,
                            java.lang.String... conditions)
```
    Deletes all records with details given if they match a set of conditions supplied. This method constructs a single SQL DELETE statement and sends it to the database.
```
 LitePal.deleteAll(Person.class, "name = ? and age = ?", "Tom", "14");
 
```
    This means that all the records which name is Tom and age is 14 will be removed.
    参数:
    
    modelClass - Which table to delete from by class.
    
    conditions - A string array representing the WHERE part of an SQL statement. First parameter is the WHERE clause to apply when deleting. The way of specifying place holders is to insert one or more question marks in the SQL. The first question mark is replaced by the second element of the array, the next question mark by the third, and so on. Passing empty string will update all rows.
    
    返回:
    
    The number of rows affected.
  - deleteAllAsync
```
@Deprecated
public static UpdateOrDeleteExecutor deleteAllAsync(java.lang.Class<?> modelClass,
                                                                 java.lang.String... conditions)
```
    已过时。
    
    This method is deprecated and will be removed in the future releases. Handle async db operation in your own logic instead.
  - deleteAll
```
public static int deleteAll(java.lang.String tableName,
                            java.lang.String... conditions)
```
    Deletes all records with details given if they match a set of conditions supplied. This method constructs a single SQL DELETE statement and sends it to the database.
```
 LitePal.deleteAll("person", "name = ? and age = ?", "Tom", "14");
 
```
    This means that all the records which name is Tom and age is 14 will be removed.
    Note that this method won't delete the referenced data in other tables. You should remove those values by your own.
    参数:
    
    tableName - Which table to delete from.
    
    conditions - A string array representing the WHERE part of an SQL statement. First parameter is the WHERE clause to apply when deleting. The way of specifying place holders is to insert one or more question marks in the SQL. The first question mark is replaced by the second element of the array, the next question mark by the third, and so on. Passing empty string will update all rows.
    
    返回:
    
    The number of rows affected.
  - deleteAllAsync
```
@Deprecated
public static UpdateOrDeleteExecutor deleteAllAsync(java.lang.String tableName,
                                                                 java.lang.String... conditions)
```
    已过时。
    
    This method is deprecated and will be removed in the future releases. Handle async db operation in your own logic instead.
  - update
```
public static int update(java.lang.Class<?> modelClass,
                         android.content.ContentValues values,
                         long id)
```
    Updates the corresponding record by id with ContentValues. Returns the number of affected rows.
```
 ContentValues cv = new ContentValues();
 cv.put("name", "Jim");
 LitePal.update(Person.class, cv, 1);
 
```
    This means that the name of record 1 will be updated into Jim.
    参数:
    
    modelClass - Which table to update by class.
    
    values - A map from column names to new column values. null is a valid value that will be translated to NULL.
    
    id - Which record to update.
    
    返回:
    
    The number of rows affected.
  - updateAsync
```
@Deprecated
public static UpdateOrDeleteExecutor updateAsync(java.lang.Class<?> modelClass,
                                                              android.content.ContentValues values,
                                                              long id)
```
    已过时。
    
    This method is deprecated and will be removed in the future releases. Handle async db operation in your own logic instead.
  - updateAll
```
public static int updateAll(java.lang.Class<?> modelClass,
                            android.content.ContentValues values,
                            java.lang.String... conditions)
```
    Updates all records with details given if they match a set of conditions supplied. This method constructs a single SQL UPDATE statement and sends it to the database.
```
 ContentValues cv = new ContentValues();
 cv.put("name", "Jim");
 LitePal.update(Person.class, cv, "name = ?", "Tom");
 
```
    This means that all the records which name is Tom will be updated into Jim.
    参数:
    
    modelClass - Which table to update by class.
    
    values - A map from column names to new column values. null is a valid value that will be translated to NULL.
    
    conditions - A string array representing the WHERE part of an SQL statement. First parameter is the WHERE clause to apply when updating. The way of specifying place holders is to insert one or more question marks in the SQL. The first question mark is replaced by the second element of the array, the next question mark by the third, and so on. Passing empty string will update all rows.
    
    返回:
    
    The number of rows affected.
  - updateAllAsync
```
@Deprecated
public static UpdateOrDeleteExecutor updateAllAsync(java.lang.Class<?> modelClass,
                                                                 android.content.ContentValues values,
                                                                 java.lang.String... conditions)
```
    已过时。
    
    This method is deprecated and will be removed in the future releases. Handle async db operation in your own logic instead.
  - updateAll
```
public static int updateAll(java.lang.String tableName,
                            android.content.ContentValues values,
                            java.lang.String... conditions)
```
    Updates all records with details given if they match a set of conditions supplied. This method constructs a single SQL UPDATE statement and sends it to the database.
```
 ContentValues cv = new ContentValues();
 cv.put("name", "Jim");
 LitePal.update("person", cv, "name = ?", "Tom");
 
```
    This means that all the records which name is Tom will be updated into Jim.
    参数:
    
    tableName - Which table to update.
    
    values - A map from column names to new column values. null is a valid value that will be translated to NULL.
    
    conditions - A string array representing the WHERE part of an SQL statement. First parameter is the WHERE clause to apply when updating. The way of specifying place holders is to insert one or more question marks in the SQL. The first question mark is replaced by the second element of the array, the next question mark by the third, and so on. Passing empty string will update all rows.
    
    返回:
    
    The number of rows affected.
  - updateAllAsync
```
@Deprecated
public static UpdateOrDeleteExecutor updateAllAsync(java.lang.String tableName,
                                                                 android.content.ContentValues values,
                                                                 java.lang.String... conditions)
```
    已过时。
    
    This method is deprecated and will be removed in the future releases. Handle async db operation in your own logic instead.
  - saveAll
```
public static <T extends LitePalSupport> boolean saveAll(java.util.Collection<T> collection)
```
    Saves the collection into database.
```
 LitePal.saveAll(people);
 
```
    If the model in collection is a new record gets created in the database, otherwise the existing record gets updated.
    If saving process failed by any accident, the whole action will be cancelled and your database will be rolled back.
    This method acts the same result as the below way, but much more efficient.
```
 for (Person person : people) {
        person.save();
 }
 
```
    So when your collection holds huge of models, saveAll(Collection) is the better choice.
    参数:
    
    collection - Holds all models to save.
    
    返回:
    
    True if all records in collection are saved. False none record in collection is saved. There won't be partial saved condition.
  - saveAllAsync
```
@Deprecated
public static <T extends LitePalSupport> SaveExecutor saveAllAsync(java.util.Collection<T> collection)
```
    已过时。
    
    This method is deprecated and will be removed in the future releases. Handle async db operation in your own logic instead.
  - markAsDeleted
```
public static <T extends LitePalSupport> void markAsDeleted(java.util.Collection<T> collection)
```
    Provide a way to mark all models in collection as deleted. This means these models' save state is no longer exist anymore. If save them again, they will be treated as inserting new data instead of updating the exist one.
    
    参数:
    
    collection - Collection of models which want to mark as deleted and clear their save state.
  - isExist
```
public static <T> boolean isExist(java.lang.Class<T> modelClass,
                                  java.lang.String... conditions)
```
    Check if the specified conditions data already exists in the table.
    
    参数:
    
    modelClass - Which table to check by class.
    
    conditions - A filter declaring which data to check. Exactly same use as where(String...), except null conditions will result in false.
    
    返回:
    
    Return true if the specified conditions data already exists in the table. False otherwise. Null conditions will result in false.
  - registerDatabaseListener
```
public static void registerDatabaseListener(DatabaseListener listener)
```
    Register a listener to listen database create and upgrade events.
  - getDBListener
```
public static DatabaseListener getDBListener()
```

类 Operator

构造器概要

方法概要

从类继承的方法 java.lang.Object

构造器详细资料

Operator

方法详细资料

getHandler

initialize

getDatabase

beginTransaction

endTransaction

setTransactionSuccessful

use

useDefault

deleteDatabase

aesKey

select

where

order

limit

offset

count

countAsync

count

countAsync

average

averageAsync

average

averageAsync

max

maxAsync

max

maxAsync

min

minAsync

min

minAsync

sum

sumAsync

sum

sumAsync

find

findAsync

find

findAsync

findFirst

findFirstAsync

findFirst

findFirstAsync

findLast

findLastAsync

findLast

findLastAsync

findAll

findAllAsync

findAll

findAllAsync

findBySQL

delete

deleteAsync

deleteAll

deleteAllAsync

deleteAll

deleteAllAsync

update

updateAsync

updateAll

updateAllAsync

updateAll

updateAllAsync

saveAll

saveAllAsync

markAsDeleted

isExist

registerDatabaseListener

getDBListener