Docjar: A Java Source and Docuemnt Enginecom.*    java.*    javax.*    org.*    all    new    plug-in

Quick Search    Search Deep

org.dbunit.ant.* (10)org.dbunit.database.* (55)org.dbunit.dataset.* (191)org.dbunit.ext.* (20)
org.dbunit.operation.* (27)org.dbunit.util.* (22)

org.dbunit: Javadoc index of package org.dbunit.


Package Samples:

org.dbunit.ant
org.dbunit.database.statement
org.dbunit.database
org.dbunit.dataset.csv.handlers
org.dbunit.dataset.csv
org.dbunit.dataset.datatype
org.dbunit.dataset.excel
org.dbunit.dataset.filter
org.dbunit.dataset.stream
org.dbunit.dataset.xml
org.dbunit.dataset
org.dbunit.ext.db2
org.dbunit.ext.mssql
org.dbunit.ext.mysql
org.dbunit.ext.oracle
org.dbunit.operation.mssqlserver
org.dbunit.operation
org.dbunit.util.concurrent
org.dbunit.util.xml
org.dbunit.util

Classes:

Channel: Main interface for buffers, queues, pipes, conduits, etc. A Channel represents anything that you can put items into and take them out of. As with the Sync interface, both blocking (put(x), take), and timeouts (offer(x, msecs), poll(msecs)) policies are provided. Using a zero timeout for offer and poll results in a pure balking policy. To aid in efforts to use Channels in a more typesafe manner, this interface extends Puttable and Takable. You can restrict arguments of instance variables to this type as a way of guaranteeing that producers never try to take, or consumers put. for example: class ...
Sync: Main interface for locks, gates, and conditions. Sync objects isolate waiting and notification for particular logical states, resource availability, events, and the like that are shared across multiple threads. Use of Syncs sometimes (but by no means always) adds flexibility and efficiency compared to the use of plain java monitor methods and locking, and are sometimes (but by no means always) simpler to program with. Most Syncs are intended to be used primarily (although not exclusively) in before/after constructions such as: class X { Sync gate; // ... public void m() { try { gate.acquire(); ...
SynchronizedVariable: Base class for simple, small classes maintaining single values that are always accessed and updated under synchronization. Since defining them for only some types seemed too arbitrary, they exist for all basic types, although it is hard to imagine uses for some. These classes mainly exist so that you do not have to go to the trouble of writing your own miscellaneous classes and methods in situations including: When you need or want to offload an instance variable to use its own synchronization lock. When these objects are used to replace instance variables, they should almost always be declared ...
Semaphore: Base class for counting semaphores. Conceptually, a semaphore maintains a set of permits. Each acquire() blocks if necessary until a permit is available, and then takes it. Each release adds a permit. However, no actual permit objects are used; the Semaphore just keeps a count of the number available and acts accordingly. A semaphore initialized to 1 can serve as a mutual exclusion lock. Different implementation subclasses may provide different ordering guarantees (or lack thereof) surrounding which threads will be resumed upon a signal. The default implementation makes NO guarantees about the ...
PropertyChangeMulticaster: This class is interoperable with java.beans.PropertyChangeSupport, but relies on a streamlined copy-on-write scheme similar to that used in CopyOnWriteArrayList. This leads to much better performance in most event-intensive programs. It also adheres to clarified semantics of add and remove operations. Sample usage. class Thing { protected Color myColor = Color.red; // an example property protected PropertyChangeMulticaster listeners = new PropertyChangeMulticaster(this); // registration methods, including: void addListener(PropertyChangeListener l) { // Use the `ifAbsent' version to avoid duplicate ...
FlatXmlDataSet: Reads and writes flat XML dataset document. Each XML element corresponds to a table row. Each XML element name corresponds to a table name. The XML attributes correspond to table columns. Flat XML dataset document sample: <!DOCTYPE dataset SYSTEM "my-dataset.dtd"> <dataset> <TEST_TABLE COL0="row 0 col 0" COL1="row 0 col 1" COL2="row 0 col 2"/> <TEST_TABLE COL1="row 1 col 1"/> <SECOND_TABLE COL0="row 0 col 0" COL1="row 0 col 1" /> <EMPTY_TABLE/> </dataset> To specify null values, omit corresponding attribute. In the above example, missing COL0 and COL2 attributes ...
Executor: Interface for objects that execute Runnables, as well as various objects that can be wrapped as Runnables. The main reason to use Executor throughout a program or subsystem is to provide flexibility: You can easily change from using thread-per-task to using pools or queuing, without needing to change most of your code that generates tasks. The general intent is that execution be asynchronous, or at least independent of the caller. For example, one of the simplest implementations of execute (as performed in ThreadedExecutor) is new Thread(command).start(); . However, this interface allows implementations ...
AmbiguousTableNameException: This exception is thrown by DatabaseDataSet when a multiple tables having the same name are accessible. This usually occurs when the database connection have access to multiple schemas containing identical table names. Possible solutions: 1) Use a database connection credential that has access to only one database schema. 2) Specify a schema name to the DatabaseConnection or DatabaseDataSourceConnection constructor. 3) Enable the qualified table name support (see How-to documentation).
BoundedLinkedQueue: A bounded variant of LinkedQueue class. This class may be preferable to BoundedBuffer because it allows a bit more concurency among puts and takes, because it does not pre-allocate fixed storage for elements, and allows capacity to be dynamically reset. On the other hand, since it allocates a node object on each put, it can be slow on systems with slow allocation and GC. Also, it may be preferable to LinkedQueue when you need to limit the capacity to prevent resource exhaustion. This protection normally does not hurt much performance-wise: When the queue is not empty or full, most puts and takes ...
SynchronousChannel: A rendezvous channel, similar to those used in CSP and Ada. Each put must wait for a take, and vice versa. Synchronous channels are well suited for handoff designs, in which an object running in one thread must synch up with an object running in another thread in order to hand it some information, event, or task. If you only need threads to synch up without exchanging information, consider using a Barrier. If you need bidirectional exchanges, consider using a Rendezvous. [ Introduction to this package. ]
DeleteAllOperation: Deletes all rows of tables present in the specified dataset. If the dataset does not contains a particular table, but that table exists in the database, the database table is not affected. Table are truncated in reverse sequence. This operation has the same effect of as TruncateTableOperation . TruncateTableOperation is faster, and it is non-logged, meaning it cannot be rollback. DeleteAllOperation is more portable because not all database vendor support TRUNCATE_TABLE TABLE statement.
TruncateTableOperation: Truncate tables present in the specified dataset. If the dataset does not contains a particular table, but that table exists in the database, the database table is not affected. Table are truncated in reverse sequence. This operation has the same effect of as DeleteAllOperation . TruncateTableOperation is faster, and it is non-logged, meaning it cannot be rollback. DeleteAllOperation is more portable because not all database vendor support TRUNCATE_TABLE TABLE statement.
InsertIdentityOperation: This class disable the MS SQL Server automatic identifier generation for the execution of inserts. If you are using the Microsoft driver (i.e. com.microsoft.jdbc.sqlserver.SQLServerDriver ), you'll need to use the SelectMethod=cursor parameter in the JDBC connection string. Your databaseUrl would look something like the following: jdbc:microsoft:sqlserver://localhost:1433;DatabaseName=mydb;SelectMethod=cursor Thanks to Jeremy Stein how have submited multiple patches.
InsertIdentityOperation: This class disable the MS SQL Server automatic identifier generation for the execution of inserts. If you are using the Microsoft driver (i.e. com.microsoft.jdbc.sqlserver.SQLServerDriver ), you'll need to use the SelectMethod=cursor parameter in the JDBC connection string. Your databaseUrl would look something like the following: jdbc:microsoft:sqlserver://localhost:1433;DatabaseName=mydb;SelectMethod=cursor Thanks to Jeremy Stein who have submited multiple patches.
Slot: A one-slot buffer, using semaphores to control access. Slots are usually more efficient and controllable than using other bounded buffers implementations with capacity of 1. Among other applications, Slots can be convenient in token-passing designs: Here. the Slot holds a some object serving as a token, that can be obtained and returned by various threads. [ Introduction to this package. ]
LinkedQueue: A linked list based channel implementation. The algorithm avoids contention between puts and takes when the queue is not empty. Normally a put and a take can proceed simultaneously. (Although it does not allow multiple concurrent puts or takes.) This class tends to perform more efficently than other Channel implementations in producer/consumer applications. [ Introduction to this package. ]
XmlDataSet: Reads and writes original XML dataset document. This format is very verbiose and must conform to the following DTD: <?xml version="1.0" encoding="UTF-8"?> <!ELEMENT dataset (table+)> <!ELEMENT table (column*, row*)> <!ATTLIST table name CDATA #REQUIRED > <!ELEMENT column (#PCDATA)> <!ELEMENT row (value | null | none)*> <!ELEMENT value (#PCDATA)> <!ELEMENT null EMPTY>
AbstractTableFilter: This class provides a skeletal implementation of the ITableFilter interface to minimize the effort required to implement a filter. Subsclasses are only required to implement the isValidName(java.lang.String) 55 method.
Puttable: This interface exists to enable stricter type checking for channels. A method argument or instance variable in a producer object can be declared as only a Puttable rather than a Channel, in which case a Java compiler will disallow take operations. Full method descriptions appear in the Channel interface. [ Introduction to this package. ]
Takable: This interface exists to enable stricter type checking for channels. A method argument or instance variable in a consumer object can be declared as only a Takable rather than a Channel, in which case a Java compiler will disallow put operations. Full method descriptions appear in the Channel interface. [ Introduction to this package. ]
SequenceTableFilter: This filter expose a specified table sequence and can be used to reorder tables in a dataset. This implementation do not support duplicate table names. Thus you cannot specify the same table name more than once in this filter and the filtered dataset must not contains duplicate table names. This is the default filter used by the org.dbunit.dataset.FilteredDataSet .
DatabaseSequenceFilter: This filter orders tables using dependency information provided by DatabaseMetaData.getExportedKeys(java.lang.String, java.lang.String, java.lang.String) > DatabaseMetaData.getExportedKeys(java.lang.String, java.lang.String, java.lang.String) 55 .
Base64: I am placing this code in the Public Domain. Do with it as you will. This software comes with no guarantees or warranties but with plenty of well-wishing instead! Please visit http://iharder.net/base64 periodically to check for updates or to contribute improvements.
BoundedChannel: A channel that is known to have a capacity, signifying that put operations may block when the capacity is reached. Various implementations may have intrinsically hard-wired capacities, capacities that are fixed upon construction, or dynamically adjustable capacities.
TimeoutException: Thrown by synchronization classes that report timeouts via exceptions. The exception is treated as a form (subclass) of InterruptedException. This both simplifies handling, and conceptually reflects the fact that timed-out operations are artificially interrupted by timers.

Home | Contact Us | Privacy Policy | Terms of Service