## org.sqlite
Class SQLiteConfig

    java.lang.Object
      org.sqlite.SQLiteConfig

    public class SQLiteConfig

extends Object

SQLite Configuration See also http://www.sqlite.org/pragma.html

Author:
  leo

Nested Class Summary
`static class` `SQLiteConfig.Encoding`
`static class` `SQLiteConfig.JournalMode`
`static class` `SQLiteConfig.LockingMode`
`static class` `SQLiteConfig.SynchronousMode`
`static class` `SQLiteConfig.TempStore`

Constructor Summary
`SQLiteConfig()`
`SQLiteConfig(Properties prop)`

Method Summary
`void` `apply(Connection conn)` Apply the current configuration to connection
`void` `enableCaseSensitiveLike(boolean enable)`
`void` `enableCountChanges(boolean enable)`
`void` `enableEmptyResultCallBacks(boolean enable)`
`void` `enableFullColumnNames(boolean enable)`
`void` `enableFullSync(boolean enable)`
`void` `enableLoadExtension(boolean enable)`
`void` `enableRecursiveTriggers(boolean enable)`
`void` `enableReverseUnorderedSelects(boolean enable)`
`void` `enableShortColumnNames(boolean enable)`
`void` `enforceForeignKeys(boolean enforce)`
`int` `getOpenModeFlags()`
`void` `incrementalVacuum(int numberOfPagesToBeRemoved)`
`boolean` `isEnabledLoadExtension()`
`boolean` `isEnabledSharedCache()`
`void` `resetOpenMode(SQLiteOpenMode mode)` Reset the specified database open mode flag
`void` `setCacheSize(int numberOfPages)`
`void` `setDefaultCacheSize(int numberOfPages)` Set the cache size persistently across database connections
`void` `setEncoding(SQLiteConfig.Encoding encoding)`
`void` `setJounalSizeLimit(int limit)`
`void` `setJournalMode(SQLiteConfig.JournalMode mode)`
`void` `setLockingMode(SQLiteConfig.LockingMode mode)`
`void` `setMaxPageCount(int numPages)`
`void` `setOpenMode(SQLiteOpenMode mode)` Set the database open mode
`void` `setPageSize(int numBytes)`
`void` `setPragma(org.sqlite.SQLiteConfig.Pragma pragma, String value)` Set a pragma value.
`void` `setReadOnly(boolean readOnly)`
`void` `setReadUncommited(boolean useReadUncommitedIsolationMode)`
`void` `setSharedCache(boolean enable)`
`void` `setSynchronous(SQLiteConfig.SynchronousMode mode)`
`void` `setTempStore(SQLiteConfig.TempStore storeType)`
`void` `setTempStoreDirectory(String directoryName)`
`void` `setUserVersion(int version)`
`Properties` `toProperties()` Convert this SQLiteConfig settings into a Properties object, that can be passed to the `DriverManager.getConnection(String, Properties)`.
`void` `useLegacyFileFormat(boolean use)`

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

Constructor Detail

### SQLiteConfig

    public SQLiteConfig()

### SQLiteConfig

    public SQLiteConfig(Properties prop)

Method Detail

### apply

    public void apply(Connection conn)
               throws SQLException

  Apply the current configuration to connection

  Parameters:
    `conn` -
  Throws:
    `SQLException`

### isEnabledSharedCache

    public boolean isEnabledSharedCache()

### isEnabledLoadExtension

    public boolean isEnabledLoadExtension()

### getOpenModeFlags

    public int getOpenModeFlags()

### setPragma

    public void setPragma(org.sqlite.SQLiteConfig.Pragma pragma,
                          String value)

  Set a pragma value. To take effect the pragma settings,

  Parameters:
    `pragma` -
    `value` -

### toProperties

    public Properties toProperties()

  Convert this SQLiteConfig settings into a Properties object, that can be passed to the `DriverManager.getConnection(String, Properties)`.

  Returns:
    properties representation of this configuration

### setOpenMode

    public void setOpenMode(SQLiteOpenMode mode)

  Set the database open mode

  Parameters:
    `mode` -

### resetOpenMode

    public void resetOpenMode(SQLiteOpenMode mode)

  Reset the specified database open mode flag

  Parameters:
    `mode` -

### setSharedCache

    public void setSharedCache(boolean enable)

### enableLoadExtension

    public void enableLoadExtension(boolean enable)

### setReadOnly

    public void setReadOnly(boolean readOnly)

### setCacheSize

    public void setCacheSize(int numberOfPages)

### enableCaseSensitiveLike

    public void enableCaseSensitiveLike(boolean enable)

### enableCountChanges

    public void enableCountChanges(boolean enable)

### setDefaultCacheSize

    public void setDefaultCacheSize(int numberOfPages)

  Set the cache size persistently across database connections

  Parameters:
    `numberOfPages` -

### enableEmptyResultCallBacks

    public void enableEmptyResultCallBacks(boolean enable)

### setEncoding

    public void setEncoding(SQLiteConfig.Encoding encoding)

### enforceForeignKeys

    public void enforceForeignKeys(boolean enforce)

### enableFullColumnNames

    public void enableFullColumnNames(boolean enable)

### enableFullSync

    public void enableFullSync(boolean enable)

### incrementalVacuum

    public void incrementalVacuum(int numberOfPagesToBeRemoved)

### setJournalMode

    public void setJournalMode(SQLiteConfig.JournalMode mode)

### setJounalSizeLimit

    public void setJounalSizeLimit(int limit)

### useLegacyFileFormat

    public void useLegacyFileFormat(boolean use)

### setLockingMode

    public void setLockingMode(SQLiteConfig.LockingMode mode)

### setPageSize

    public void setPageSize(int numBytes)

### setMaxPageCount

    public void setMaxPageCount(int numPages)

### setReadUncommited

    public void setReadUncommited(boolean useReadUncommitedIsolationMode)

### enableRecursiveTriggers

    public void enableRecursiveTriggers(boolean enable)

### enableReverseUnorderedSelects

    public void enableReverseUnorderedSelects(boolean enable)

### enableShortColumnNames

    public void enableShortColumnNames(boolean enable)

### setSynchronous

    public void setSynchronous(SQLiteConfig.SynchronousMode mode)

### setTempStore

    public void setTempStore(SQLiteConfig.TempStore storeType)

### setTempStoreDirectory

    public void setTempStoreDirectory(String directoryName)

### setUserVersion

    public void setUserVersion(int version)

This work is licensed under a Creative Commons Attribution-ShareAlike 2.1 Japan License.