| Package | Description |
|---|---|
| org.pentaho.di.core.database |
Contains all the different database dialects as well as the DatabaseMeta class (definition) and the Database class (execution)
|
| org.pentaho.di.core.database.util | |
| org.pentaho.di.core.exception |
This package contains a set of Exceptions used in Kettle.
|
| org.pentaho.di.core.row | |
| org.pentaho.di.core.row.value |
| Modifier and Type | Class and Description |
|---|---|
class |
DataSourceNamingException
This class provides a wrapper around NamingException or other exceptions that may occur when trying to get a data
source by name.
|
| Modifier and Type | Method and Description |
|---|---|
boolean |
Database.absolute(ResultSet rs,
int position) |
void |
Database.afterLast(ResultSet rs) |
RowMetaAndData |
Database.callProcedure(String[] arg,
String[] argdir,
int[] argtype,
String resultname,
int resulttype) |
void |
Database.cancelQuery()
Cancel the open/running queries on the database connection
|
void |
Database.cancelStatement(Statement statement)
Cancel an open/running SQL statement
|
boolean |
Database.checkColumnExists(String columnname,
String tablename)
See if the column specified exists by reading
|
boolean |
DatabaseInterface.checkIndexExists(Database database,
String schemaName,
String tableName,
String[] idxFields)
Verifies on the specified database connection if an index exists on the fields with the specified name.
|
boolean |
MSAccessDatabaseMeta.checkIndexExists(Database database,
String schemaName,
String tableName,
String[] idx_fields)
Verifies on the specified database connection if an index exists on the fields with the specified name.
|
boolean |
OracleDatabaseMeta.checkIndexExists(Database database,
String schemaName,
String tableName,
String[] idx_fields)
Verifies on the specified database connection if an index exists on the fields with the specified name.
|
boolean |
Exasol4DatabaseMeta.checkIndexExists(Database database,
String schemaName,
String tableName,
String[] idx_fields)
Verifies on the specified database connection if an index exists on the fields with the specified name.
|
boolean |
MSSQLServerDatabaseMeta.checkIndexExists(Database database,
String schemaName,
String tableName,
String[] idx_fields)
Verifies on the specified database connection if an index exists on the fields with the specified name.
|
boolean |
BaseDatabaseMeta.checkIndexExists(Database database,
String schemaName,
String tableName,
String[] idx_fields)
Verifies on the specified database connection if an index exists on the fields with the specified name.
|
boolean |
Database.checkIndexExists(String tableName,
String[] idx_fields)
Check if an index on certain fields in a table exists.
|
boolean |
Database.checkIndexExists(String schemaName,
String tableName,
String[] idx_fields)
Check if an index on certain fields in a table exists.
|
boolean |
Database.checkSequenceExists(String sequenceName)
Check whether the sequence exists, Oracle only!
|
boolean |
Database.checkSequenceExists(String schemaName,
String sequenceName)
Check whether the sequence exists, Oracle only!
|
boolean |
Database.checkTableExists(String tablename)
See if the table specified exists by reading
|
void |
Database.cleanupLogRecords(LogTableCoreInterface logTable) |
void |
Database.clearBatch(PreparedStatement preparedStatement) |
void |
Database.clearInsertBatch()
Deprecated.
|
void |
Database.closeConnectionOnly()
Only for unique connections usage, typically you use disconnect() to disconnect() from the database.
|
void |
Database.closeInsert() |
void |
Database.closeLookup() |
void |
Database.closePreparedStatement(PreparedStatement ps) |
void |
Database.closeProcedureStatement() |
void |
Database.closeQuery(ResultSet res) |
void |
Database.closeUpdate() |
void |
Database.commit()
Perform a commit the connection if this is supported by the database
|
void |
DatabaseTransactionListener.commit() |
void |
Database.commit(boolean force) |
void |
Database.commitLog(boolean force,
LogTableCoreInterface logTable)
This methods may be removed in future.
|
void |
Database.commitLog(LogTableCoreInterface logTable)
This methods may be removed in future.
|
void |
Database.connect()
Open the database connection.
|
void |
Database.connect(String partitionId)
Open the database connection.
|
void |
Database.connect(String group,
String partitionId) |
void |
Database.emptyAndCommit(PreparedStatement ps,
boolean batch)
Close the passed prepared statement.
|
void |
Database.emptyAndCommit(PreparedStatement ps,
boolean batch,
int batchCounter)
Close the prepared statement of the insert statement.
|
Result |
Database.execStatement(String sql)
Execute an SQL statement on the database connection (has to be open)
|
Result |
Database.execStatement(String rawsql,
RowMetaInterface params,
Object[] data) |
Result |
Database.execStatements(String script)
Execute a series of SQL statements, separated by ;
We are already connected...
|
Result |
Database.execStatements(String script,
RowMetaInterface params,
Object[] data)
Execute a series of SQL statements, separated by ;
We are already connected...
|
void |
Database.executeAndClearBatch(PreparedStatement preparedStatement) |
void |
Database.first(ResultSet rs) |
String |
Database.getAlterTableStatement(String tableName,
RowMetaInterface fields,
String tk,
boolean use_autoinc,
String pk,
boolean semicolon) |
String[] |
Database.getCatalogs() |
String |
DatabaseFactoryInterface.getConnectionTestReport(DatabaseMeta databaseMeta) |
String |
DatabaseFactory.getConnectionTestReport(DatabaseMeta databaseMeta) |
void |
DatabaseMetaInformation.getData(LoggingObjectInterface parentLoggingObject,
ProgressMonitorListener monitor) |
static DatabaseInterface |
DatabaseMeta.getDatabaseInterface(String databaseType)
Search for the right type of DatabaseInterface object and clone it.
|
DatabaseMetaData |
Database.getDatabaseMetaData() |
String |
Database.getDDL(String tablename,
RowMetaInterface fields) |
String |
Database.getDDL(String tablename,
RowMetaInterface fields,
String tk,
boolean use_autoinc,
String pk) |
String |
Database.getDDL(String tableName,
RowMetaInterface fields,
String tk,
boolean use_autoinc,
String pk,
boolean semicolon) |
String |
Database.getDDLCreationTable(String tableName,
RowMetaInterface fields)
Return SQL CREATION statement for a Table
|
String |
Database.getDDLTruncateTable(String schema,
String tablename)
Return SQL TRUNCATE statement for a Table
|
List<Object[]> |
Database.getFirstRows(String table_name,
int limit) |
List<Object[]> |
Database.getFirstRows(String table_name,
int limit,
ProgressMonitorListener monitor)
Get the first rows from a table (for preview)
|
RowMetaAndData |
Database.getGeneratedKeys(PreparedStatement ps) |
Object[] |
Database.getLastLogDate(String logtable,
String name,
boolean job,
LogStatus status) |
Object[] |
Database.getLookup() |
Object[] |
Database.getLookup(boolean failOnMultipleResults) |
Object[] |
Database.getLookup(PreparedStatement ps) |
Object[] |
Database.getLookup(PreparedStatement ps,
boolean failOnMultipleResults) |
RowMeta |
Database.getMetaFromRow(Object[] row,
ResultSetMetaData md) |
Long |
DatabaseInterface.getNextBatchId(DatabaseMeta dbm,
Database ldb,
String schemaName,
String tableName,
String fieldName)
Get the next Batch ID from the logging tables.
|
Long |
BaseDatabaseMeta.getNextBatchId(DatabaseMeta dbm,
Database ldb,
String schemaName,
String tableName,
String fieldName) |
Long |
DatabaseMeta.getNextBatchId(Database ldb,
String schemaName,
String tableName,
String fieldName) |
Long |
BaseDatabaseMeta.getNextBatchIdUsingAutoIncSQL(String autoIncSQL,
DatabaseMeta dbm,
Database ldb) |
Long |
MSSQLServerDatabaseMeta.getNextBatchIdUsingLockTables(DatabaseMeta dbm,
Database ldb,
String schemaName,
String tableName,
String fieldName) |
Long |
BaseDatabaseMeta.getNextBatchIdUsingLockTables(DatabaseMeta dbm,
Database ldb,
String schemaName,
String tableName,
String fieldName) |
Long |
BaseDatabaseMeta.getNextBatchIdUsingSequence(String sequenceName,
String schemaName,
DatabaseMeta dbm,
Database ldb) |
Long |
Database.getNextSequenceValue(String sequenceName,
String keyfield) |
Long |
Database.getNextSequenceValue(String schemaName,
String sequenceName,
String keyfield) |
Long |
Database.getNextValue(Hashtable<String,Counter> counters,
String tableName,
String val_key) |
Long |
Database.getNextValue(Hashtable<String,Counter> counters,
String schemaName,
String tableName,
String val_key) |
RowMetaAndData |
Database.getOneRow(String sql)
Execute a query and return at most one row from the resultset
|
RowMetaAndData |
Database.getOneRow(String sql,
RowMetaInterface param,
Object[] data) |
String[] |
Database.getPrimaryKeyColumnNames(String tablename)
Return primary key column names ...
|
String[] |
Database.getProcedures() |
RowMetaInterface |
Database.getQueryFields(String sql,
boolean param) |
RowMetaInterface |
Database.getQueryFields(String sql,
boolean param,
RowMetaInterface inform,
Object[] data) |
Object[] |
Database.getRow(ResultSet rs)
Get a row from the resultset.
|
Object[] |
Database.getRow(ResultSet rs,
boolean lazyConversion)
Get a row from the resultset.
|
Object[] |
Database.getRow(ResultSet rs,
ResultSetMetaData dummy,
RowMetaInterface rowInfo)
Get a row from the resultset.
|
List<Object[]> |
Database.getRows(ResultSet rset,
int limit,
ProgressMonitorListener monitor)
Reads the result of a ResultSet into an ArrayList
|
List<Object[]> |
Database.getRows(String sql,
int limit)
Reads the result of an SQL query into an ArrayList
|
List<Object[]> |
Database.getRows(String sql,
int limit,
ProgressMonitorListener monitor)
Reads the result of an SQL query into an ArrayList
|
List<Object[]> |
Database.getRows(String sql,
RowMetaInterface params,
Object[] data,
int fetch_mode,
boolean lazyConversion,
int limit,
ProgressMonitorListener monitor)
Reads the result of an SQL query into an ArrayList.
|
String[] |
Database.getSchemas() |
String[] |
Database.getSequences()
Return all sequence names from connection
|
String |
Database.getSQLOutput(String schemaName,
String tableName,
RowMetaInterface fields,
Object[] r,
String dateFormat)
Return SQL statement (INSERT INTO TableName ...
|
Map<String,Collection<String>> |
Database.getSynonymMap() |
Map<String,Collection<String>> |
Database.getSynonymMap(String schemanamein) |
String[] |
Database.getSynonyms() |
String[] |
Database.getSynonyms(boolean includeSchema) |
String[] |
Database.getSynonyms(String schemanamein,
boolean includeSchema) |
RowMetaInterface |
Database.getTableFields(String tablename) |
Map<String,Collection<String>> |
Database.getTableMap() |
Map<String,Collection<String>> |
Database.getTableMap(String schemanamein) |
String[] |
Database.getTablenames() |
String[] |
Database.getTablenames(boolean includeSchema) |
String[] |
Database.getTablenames(String schemanamein,
boolean includeSchema) |
String[] |
Database.getTableTypes() |
String |
DatabaseMeta.getURL() |
String |
DatabaseMeta.getURL(String partitionId) |
String |
DatabaseInterface.getURL(String hostname,
String port,
String databaseName) |
String |
OracleDatabaseMeta.getURL(String hostname,
String port,
String databaseName) |
String |
NeoviewDatabaseMeta.getURL(String hostname,
String port,
String databaseName) |
String |
Exasol4DatabaseMeta.getURL(String hostname,
String port,
String databaseName) |
boolean |
Database.getUseBatchInsert(boolean batch) |
Object |
DatabaseInterface.getValueFromResultSet(ResultSet resultSet,
ValueMetaInterface valueMeta,
int index)
This method allows a database dialect to convert database specific data types to Kettle data types.
|
Object |
NeoviewDatabaseMeta.getValueFromResultSet(ResultSet rs,
ValueMetaInterface val,
int i)
This method allows a database dialect to convert database specific data types to Kettle data types.
|
Object |
DatabaseMeta.getValueFromResultSet(ResultSet rs,
ValueMetaInterface val,
int i) |
Object |
BaseDatabaseMeta.getValueFromResultSet(ResultSet rs,
ValueMetaInterface val,
int i)
This method allows a database dialect to convert database specific data types to Kettle data types.
|
Object |
Vertica5DatabaseMeta.getValueFromResultSet(ResultSet rs,
ValueMetaInterface val,
int index)
This method allows a database dialect to convert database specific data types to Kettle data types.
|
Map<String,Collection<String>> |
Database.getViewMap() |
Map<String,Collection<String>> |
Database.getViewMap(String schemanamein) |
String[] |
Database.getViews() |
String[] |
Database.getViews(boolean includeSchema) |
String[] |
Database.getViews(String schemanamein,
boolean includeSchema) |
void |
Database.insertFinished(boolean batch) |
void |
Database.insertFinished(PreparedStatement ps,
boolean batch)
Deprecated.
use emptyAndCommit() instead (pass in the number of rows left in the batch)
|
void |
Database.insertRow() |
void |
Database.insertRow(boolean batch) |
void |
Database.insertRow(PreparedStatement ps) |
boolean |
Database.insertRow(PreparedStatement ps,
boolean batch)
Insert a row into the database using a prepared statement that has all values set.
|
boolean |
Database.insertRow(PreparedStatement ps,
boolean batch,
boolean handleCommit)
Insert a row into the database using a prepared statement that has all values set.
|
void |
Database.insertRow(String tableName,
RowMetaInterface fields,
Object[] data) |
void |
Database.insertRow(String schemaName,
String tableName,
RowMetaInterface fields,
Object[] data) |
void |
Database.lockTables(String[] tableNames)
Lock a tables in the database for write operations
|
void |
Database.normalConnect(String partitionId)
Open the database connection.
|
ResultSet |
Database.openQuery(PreparedStatement ps,
RowMetaInterface params,
Object[] data) |
ResultSet |
Database.openQuery(String sql) |
ResultSet |
Database.openQuery(String sql,
RowMetaInterface params,
Object[] data)
Open a query on the database with a set of parameters stored in a Kettle Row
|
ResultSet |
Database.openQuery(String sql,
RowMetaInterface params,
Object[] data,
int fetch_mode) |
ResultSet |
Database.openQuery(String sql,
RowMetaInterface params,
Object[] data,
int fetch_mode,
boolean lazyConversion) |
void |
Database.prepareInsert(RowMetaInterface rowMeta,
String tableName)
Prepare inserting values into a table, using the fields & values in a Row
|
void |
Database.prepareInsert(RowMetaInterface rowMeta,
String schemaName,
String tableName)
Prepare inserting values into a table, using the fields & values in a Row
|
PreparedStatement |
Database.prepareSQL(String sql)
Prepare a statement to be executed on the database.
|
PreparedStatement |
Database.prepareSQL(String sql,
boolean returnKeys)
Prepare a statement to be executed on the database.
|
boolean |
Database.relative(ResultSet rs,
int rows) |
void |
Database.releaseSavepoint(Savepoint savepoint) |
void |
Database.rollback() |
void |
DatabaseTransactionListener.rollback() |
void |
Database.rollback(boolean force) |
void |
Database.rollback(Savepoint savepoint) |
void |
Database.setAutoCommit(boolean useAutoCommit) |
void |
Database.setLookup(String table,
String[] codes,
String[] condition,
String[] gets,
String[] rename,
String orderby) |
void |
Database.setLookup(String tableName,
String[] codes,
String[] condition,
String[] gets,
String[] rename,
String orderby,
boolean checkForMultipleResults) |
void |
Database.setLookup(String schema,
String table,
String[] codes,
String[] condition,
String[] gets,
String[] rename,
String orderby) |
void |
Database.setLookup(String schemaName,
String tableName,
String[] codes,
String[] condition,
String[] gets,
String[] rename,
String orderby,
boolean checkForMultipleResults) |
void |
Database.setProcLookup(String proc,
String[] arg,
String[] argdir,
int[] argtype,
String returnvalue,
int returntype) |
void |
Database.setProcValues(RowMetaInterface rowMeta,
Object[] data,
int[] argnrs,
String[] argdir,
boolean result) |
Savepoint |
Database.setSavepoint() |
Savepoint |
Database.setSavepoint(String savePointName) |
void |
Database.setValue(PreparedStatement ps,
ValueMetaInterface v,
Object object,
int pos) |
void |
Database.setValues(RowMetaAndData row) |
void |
Database.setValues(RowMetaAndData row,
PreparedStatement ps) |
void |
Database.setValues(RowMetaInterface rowMeta,
Object[] data) |
void |
Database.setValues(RowMetaInterface rowMeta,
Object[] data,
PreparedStatement ps) |
void |
Database.setValues(RowMetaInterface rowMeta,
Object[] data,
PreparedStatement ps,
int ignoreThisValueIndex)
Sets the values of the preparedStatement pstmt.
|
void |
Database.setValuesInsert(RowMetaAndData row) |
void |
Database.setValuesInsert(RowMetaInterface rowMeta,
Object[] data) |
void |
Database.setValuesLookup(RowMetaInterface rowMeta,
Object[] data) |
void |
Database.setValuesUpdate(RowMetaInterface rowMeta,
Object[] data) |
void |
Database.truncateTable(String tablename) |
void |
Database.truncateTable(String schema,
String tablename) |
void |
Database.unlockTables(String[] tableNames)
Unlock certain tables in the database for write operations
|
void |
Database.updateRow() |
void |
Database.writeLogRecord(LogTableCoreInterface logTable,
LogStatus status,
Object subject,
Object parent) |
| Modifier and Type | Method and Description |
|---|---|
void |
LogExceptionBehaviourInterface.registerException(LogChannelInterface log,
Class<?> packageClass,
String key,
String... parameters)
When exception during logging is raised, depending on item settings we will throw exception up, or just put a log
record on this event.
|
void |
LogExceptionBehaviourInterface.registerException(LogChannelInterface log,
Exception e,
Class<?> packageClass,
String key,
String... parameters) |
| Modifier and Type | Class and Description |
|---|---|
class |
KettleDatabaseBatchException
This exception is used by the Database class.
|
class |
KettleDependencyException
This exception is used by the Database class.
|
| Modifier and Type | Method and Description |
|---|---|
Object |
ValueMetaInterface.getValueFromResultSet(DatabaseInterface databaseInterface,
ResultSet resultSet,
int index)
Get a value from a result set column based on the current value metadata
|
ValueMetaInterface |
ValueMetaInterface.getValueFromSQLType(DatabaseMeta databaseMeta,
String name,
ResultSetMetaData rm,
int index,
boolean ignoreLength,
boolean lazyConversion)
Investigate JDBC result set metadata at the specified index.
|
void |
ValueMetaInterface.setPreparedStatementValue(DatabaseMeta databaseMeta,
PreparedStatement preparedStatement,
int index,
Object data)
Set a value on a JDBC prepared statement on the specified position
|
| Modifier and Type | Method and Description |
|---|---|
Object |
ValueMetaTimestamp.getValueFromResultSet(DatabaseInterface databaseInterface,
ResultSet resultSet,
int index) |
Object |
ValueMetaInternetAddress.getValueFromResultSet(DatabaseInterface databaseInterface,
ResultSet resultSet,
int index) |
Object |
ValueMetaBase.getValueFromResultSet(DatabaseInterface databaseInterface,
ResultSet resultSet,
int index)
Get a value from a result set column based on the current value metadata
|
ValueMetaInterface |
ValueMetaTimestamp.getValueFromSQLType(DatabaseMeta databaseMeta,
String name,
ResultSetMetaData rm,
int index,
boolean ignoreLength,
boolean lazyConversion) |
ValueMetaInterface |
ValueMetaInternetAddress.getValueFromSQLType(DatabaseMeta databaseMeta,
String name,
ResultSetMetaData rm,
int index,
boolean ignoreLength,
boolean lazyConversion) |
ValueMetaInterface |
ValueMetaBase.getValueFromSQLType(DatabaseMeta databaseMeta,
String name,
ResultSetMetaData rm,
int index,
boolean ignoreLength,
boolean lazyConversion) |
void |
ValueMetaTimestamp.setPreparedStatementValue(DatabaseMeta databaseMeta,
PreparedStatement preparedStatement,
int index,
Object data) |
void |
ValueMetaInternetAddress.setPreparedStatementValue(DatabaseMeta databaseMeta,
PreparedStatement preparedStatement,
int index,
Object data) |
void |
ValueMetaBase.setPreparedStatementValue(DatabaseMeta databaseMeta,
PreparedStatement preparedStatement,
int index,
Object data) |