* Your assessment is very important for improving the workof artificial intelligence, which forms the content of this project
Download FastObjects Database Components
Survey
Document related concepts
Serializability wikipedia , lookup
Oracle Database wikipedia , lookup
Microsoft Access wikipedia , lookup
Entity–attribute–value model wikipedia , lookup
Microsoft SQL Server wikipedia , lookup
Extensible Storage Engine wikipedia , lookup
Ingres (database) wikipedia , lookup
Open Database Connectivity wikipedia , lookup
Concurrency control wikipedia , lookup
Functional Database Model wikipedia , lookup
Microsoft Jet Database Engine wikipedia , lookup
Relational model wikipedia , lookup
ContactPoint wikipedia , lookup
Clusterpoint wikipedia , lookup
Transcript
Database Components featured by Poet Software. PROGRAMMING INTERFACES (API) JDO 1.0 Java API ODMG 3.0 Java API Java Enhancer as post-processor C++ API QUERY LANGUAGES AND QUERY INTERFACES JDOQL (API based on Java query interface, standardized) OQL (Object Query Language, standardized ad hoc query language) PtQL (API based on C++ query interface) Advanced Query Optimizer (server-side query optimization) Filter expressions on any data collections Fast Look-up (for quick positioning in object collections) Verity full text indexing Compound indices, even beyond object limits OBJECT MODEL Fast navigation in objects and object networks Locking and Access mechanisms at object level (complete support of all concurrency levels) Watch-Notify (Callbacks support: observation and notification framework upon data changes) Storage of unknown data types (3rd party class support) Transport of objects via VM or transaction limits SECURITY User Administration Rights Management at class level Database encryption (Transparent encryption of data and indices with user-defined keys) Encrypted Client-Server Communication INTERFACES AND STANDARDS SQL Object Factory (transparent access to relational databases) Integration with Enterprise-Application Servers via J2EE-Connector-Architecture (JCA) Support of J2EE Transaction model (Session Beans und Bean-Managed Persistence) XML Support (complete import and export of objects) ODBC Driver FastObjects Database Components Features in Detail, Page 2 SCALABILITY AND PERFORMANCE Multi-Threaded Server and Load Balancing Active Cache (transparent, client-based "Object Cache") Extensive polymorphic indexing, especially on "collections” Access path (configurable bundling of reading operations) DATA SECURITY AND AVAILABILITY High availability (combination of replication and fail-over technology, support MS-Cluster Server) Shadow database (user-defined database copy to increase security in case of failure) Complete online-backup (complete data backup in an ongoing business) Incremental online-backup (configurable partial backup in an ongoing business) In-Memory databases (complete database functionality in RAM for non-disk systems. Substantial performance optimization in connection with shadow databases) Online Replication for load balancing and data security Fail-Over (Transparent, uninterrupted reactivation within seconds after server failure) RELIABILITY AND NO MAINTENANCE Checksums (permits recognition of hard disks, memory and networks errors) Automatic Recovery Online Database Check (Check of consistency in database in an ongoing business) Free space management Simple installation Schema Versioning “Versioning on the “Fly” (Changes to DB schemas in existing databases) INTERNATIONALIZATION AND SYSTEM INDEPENDENCE UNICODE strings and language-specific sorting (ISO-14651) Programming language independence Operating system independence PRODUCTIVITY AND INTEGRATION IN DEVELOPMENT ENVIRONMENT Java IDE Integration (JBuilder, Forte) UML Integration (Rational Rose, Together J) Visual database tools FastObjects Database Components Features in Detail, Page 3 FastObjects Features in Detail Programming Interface (API) If you program in object-oriented language, you should store in OO too. After all, do you know anyone who takes his car apart and then puts the individual parts carefully on a shelf instead of simply driving the car into the garage? FastObjects supports the Java and C++ object model. You can concentrate on your application model instead of writing mapping code. You save code (up to 40 percent less application code) and your application runs significantly faster. The more complex your model is, the greater the benefits of using FastObjects. JDO 1.0 Java API The JDO program interface (Java Data Objects ) is the standard for database access in Java, developed by Sun, IBM, Oracle and many others. It offers a complete programming model that’s easy to use. Applications developed with JDO are manufacturer-independent and can manage your data with various database technologies (relational or object-oriented) from all JDO-compatible manufacturers. FastObjects has worked on the specifications of JDO standards right from the start and was the first database producer to offer a complete JDO implementation for the entire FastObjects product line in June 2002. ODMG 3.0 Java API The Java programming interface of the Object Data Management Group (ODMG) was the first object-oriented standard for Java persistence. FastObjects contributed substantially to the development of the standard and has supported the standard in Version 2.0 since 1997. Version 3.0 of the standard was released in 1999 and implemented in FastObjects. Like JDO, the ODMG interface offers a transparent programming model that’s elegantly embedded in Java. Any Java class can be made persistent with its entry in a configuration file. Java Enhancer as Post-processor As a FastObjects developer, you can concentrate on your class model. Our post-processor determines the database schema from the configuration file and your class definitions, creates the database and expands the Java byte code to include database functionality. This ensures that the database schema and class definitions are always well-matched. C++ API FastObjects has had a very efficient C++ API since its first release (1991). The easy-to-use interface permits precise management of the object model. FastObjects also supports complex language mechanisms such as multiple inheritance and the embedding of objects. Complicated processes can be reproduced elegantly, thanks to a highly refined locking concept and a flexible notification model (Watch/Notify). Solid support for multitiered architecture is also offered by parallel transactions and multi-threading capability. FastObjects Database Components Features in Detail, Page 4 Query languages and query interfaces FastObjects offers a whole range of search and indexing possibilities so that you can query your objects quickly and reliably. They include direct navigation through the object network, object extents, filter expressions and database queries. JDOQL (API based on Java query interface, standardized) Those who want to remain compatible with JDO should use JDOQL, the JDO standard query language. Based on the Java class model, it follows Java very closely. This allows you to forego the learning curve associated with another query language. OQL (Object Query Language, standardized ad hoc query language) With Object Query Language, the ODMG standard offers a query language that allows ad hoc queries. A query formulated with SQL-like syntax delivers its results in the form of completely constructed objects. There’s no need to transfer query results from the SQL buffer into objects. Our OQL implementation is available for Java and C++. PtQL (API based on C++ query interface) Very often the structure of a query is determined during development so that no ad hoc query is necessary. For these application situations, FastObjects offers an efficient query API in its PtQL. Your advantage: more type security and less overhead, because preparation of query strings is no longer required. Advanced Query Optimizer (Server-side query optimizing, possibly to OQL) Regardless of the best choice of query language for your application, one fact remains: it has to be fast. For this reason, we have developed a dynamic, server-based query optimizer that improves the runtime of every query. In the process, the best indices are selected, processing steps are reorganized and path expressions are optimized. FastObjects benefit: Filter expressions for any data quantity Many application developers are familiar with the problem of how to depict large quantities of data in a browser. Due to copious amounts of data, a query takes too long and overburdens main memory. FastObjects solves this problem with server-based filters. The application formulates the filter expression for any amount of data and iterates it over suitable objects. The application can begin displaying immediately and does not have to wait for the end of the query. FastObjects benefit: Fast Lookup Your application should interactively search through great amounts of data. For example, after entry of the first letter, the pointer should go directly to the available entries under that letter. No problem with the FastObjects search() method. Lightning-fast, it positions you directly in an index. From this starting point, you can move forward or backward. The whole thing runs directly on the index trees without a query and without loading time for the object. FastObjects benefit: Verity full-text indexing These days, full-text searches are offered by all reasonable databases, at least in extensions. FastObjects goes even further. We’ve integrated the Verity full-text engine transparently into our query engine. As a result, it is possible to mix full-text queries with regular attribute queries. A FastObjects benefit. FastObjects Database Components Features in Detail, Page 5 Object Model FastObjects directly supports the Java und C++ object model. Complex class models that combine several language mechanisms (heredity, polymorphous, aggregation) can also be depicted without modification in the database. There’s no need for a translation from object model to data model, which means less database code, shorter development times and significantly improved performance. Fast Navigation in Objects In addition to queries and filters, FastObjects offers another means of access to objects: navigation. In FastObjects, C++ pointers or Java references of the object model are translated directly into database references. Pursuit of a reference, therefore, constitutes direct access to memory instead of foreign key access. This means extremely fast read time for networked objects. If the referenced object is already loaded or is in the cache, access is a straightforward main memory operation. Lock and Access Mechanisms at Object Level In matters involving lock and access mechanisms, FastObjects follows the logic of your programming language. Complete objects or object trees can be locked through a very finely configurable locking system. It minimizes locking conflicts and makes possible high-performance multi-user applications even as the transaction logic becomes more complex. Watch-Notify Especially in the management and visualization of secondary processes, FastObjects offers more than the competition. An intelligent observation and notification report (Watch/Notify) informs the client of database events (insert, update, delete, etc.) and permits quick reaction. It’s a multi-faceted deployable mechanism for cooperating processes. FastObjects benefit: Storage of Unknown Data Types You’d like to use Java classes that are not in the source code? And to store data types whose structure is unknown? No problem for the Java API from FastObjects. We can also store what we don’t understand. Even unknown data types that call up "native" code can be read and stored by FastObjects. FastObjects benefit: Transport of Objects via VM or Transaction Limits (Serializing) Sometimes you want to hand over database objects from your application server to an applet. Because your applet contains no database code and can remain small and compact. In Java there is a mechanism called serializing for just this purpose. With FastObjects, you can serialize database objects among various VMs on different computers. It also works in two directions (bi-directional), that is, your applet can make changes and report back using a standard protocol. A FastObjects benefit. FastObjects Database Components Features in Detail, Page 6 Security You really appreciate security once something has gone wrong. So that you’ll never get to that point, FastObjects offers a thorough security concept from user administration and rights management to database encryption. User Administration FastObjects supports a user administration that prevents all users from gaining access to all data and assigns specific authorization to persons and groups. And because the system allows you to package groups as required, complex roles can be easily constructed. Rights Management at Class Level In access authorization, FastObjects distinguishes among reading, changing and deleting of objects. In the process, access rights apply to all objects in a class, but can be further restricted through attributes. (Example: Clerk Miller can process only clients A to M.) Database Encryption If your database data are stolen, sensitive data have to be protected from unauthorized access. FastObjects offers you this protection by means of completely transparent database encryption. Both data and index information are encoded through the Blowfish algorithm. This encryption process is efficient and license-free. Would you rather use a different algorithm? No problem. The encryption is interchangeable. Encrypted Client-Server Communication However, security means more than only the encryption of data. When you’re communicating, no one is allowed to listen in. That’s why we also encrypt data traffic between client and server. With Open SSL, both parties negotiate a secure connection and generate a secure key. Every communication between your application and the Poet server is then bug-proof. FastObjects offers a recognized high security level, namely SSL 3.0. The same applies here: if you’d rather use the services of another encryption provider, that’s no problem. This encryption is also interchangeable. Interfaces and Standards Of course we are the best. But one can’t do everything alone. That’s why we have interfaces to other systems and applications. SQL Object Factory Do you already hold relational licenses? Does your customer insist on using a relational database? What you need is an elegant object-oriented interface. Otherwise, you’ll be short of time. With the SQL Object Factory, FastObjects offers transparent access to the most important relational database servers: Oracle, MS SQL Server and DB2. You can use our tested program interfaces in your applications for this purpose. FastObjects Database Components Features in Detail, Page 7 A FastObjects benefit: Integration in J2EE Transaction Schema Today enterprise applications are developed in Java. With links to transaction servers: Bean-Managed Persistence with Session Beans. With FastObjects, you are completely up-to-date, as far as beans are concerned. Thanks to the complete support of Enterprise Java Beans 2.0 (EJB) over resource adapter. Simple, transparent and compatible with all EJB 2.0 application servers. XML Support An XML schema contains data types and value ranges – enough information to create Java classes. Nothing is quicker than transferring the XLM structure into Java objects. It goes quickly and requires only a minimum of application code. The developer has his familiar Java interface and doesn’t have to spend time on analyzing the XML structure. It’s a simple data-binding tool and very few lines of code. Nothing more is needed to work with FastObjects XML data. Furthermore, through use of an XML-based export/import schema, we make it possible to connect to external tools for all data stored in FastObjects. ODBC Driver With its ODBC Driver, FastObjects provides a relational view of object-oriented data. You can easily connect your application to standard tools for additional analysis with a report generator or further processing with a spreadsheet. Scalability and Performance Higher performance levels with complex models is a given for FastObjects. It’s especially important to us that performance remain stable even as the number of users increases. A scalable system. Multi-Threaded Server and Load Balancing A FastObjects server can do a lot at one time. Thanks to its multi-threading architecture, FastObjects processes parallel reading access and exploits multi-processing engines to their fullest. If a multi-processing engine does not suffice, you can call on the load balancing function of the FastObjects replication mechanism. Our online replication can make as many copies of the database as required on other servers, update the databases online and make them available for online queries. Active Cache The fastest database access is one that doesn’t even have to be executed – because the object is already there. The FastObjects Active Cache notes the objects read by the client. If the object is once again required, there’s no need for network transport or disk access. A separate lock server ensures consistency in the caches of individual clients. The FastObjects Active Cache works in a transparent manner, that is, your application doesn’t change. It will simply be faster. FastObjects benefit: Access Paths In many applications, the bandwidth of the network connections is a bottleneck. In this case, the access paths of FastObjects help to reduce network loads. The application defines rules for combining sub-objects or object quantities in read operations. The referenced object is read too and the application is spared network access. Because the rules for runtime can be selected, the application can react with flexibility to different contexts. FastObjects Database Components Features in Detail, Page 8 Far-reaching polymorphous Indexing Speed is not sorcery. In database queries, speed essentially depends on available indices. FastObjects has supported the construction of complex indices since its first release. This support has been systematically expanded over the course of the past years. All attributes of a persistent class can be indexed individually or in combination with other attributes. In the process, FastObjects supports not only individual data types but also the indexing of collections within objects. In keeping with our object-oriented logic, the indexing in FastObjects is polymorphous, that is, the indices function for derived classes too. Data Security and Availability Anything that can go wrong will go wrong at some point. So that everything can continue to function properly, FastObjects offers server clusters and online backup. High Availability There are applications in which a server just can’t fail – or if it does, a replacement server has to jump in right away. That can’t happen fast enough. In a FastObjects server cluster, the backup server is always running in tandem. If the main server fails, your application can switch over as fast as lightning. We can do that even without special support from the operating system. On simple standard hardware. In seconds. Your application continues running as if nothing at all had happened. Shadow Database Protection from failure is also important in configurations without servers. That’s why j2, our real-time database, offers the chance to save a user-defined online copy. That’s security against fails on server-less systems with a shadow database for j2. Complete Online Backup Some systems cannot be shut down, but data backup still has to take place. With FastObjects’ online backup, the FastObjects server is set to backup mode even while the application is running. The backup can be made while operations continue. FastObjects stores all transactions completed during backup in a Forward Recovery Log and then loads them into the database once the backup is complete. Incremental Online Backup If a full backup requires too much memory, a partial backup can be carried out. This can also be done online. Full backups at longer intervals and partial backups in between. With these options, FastObjects offers a truly flexible security concept. In-Memory Database It may sound strange: even systems without drives need database functionality. With j2, you have complete database functionality in main memory. That also means that you have the speed of the main memory. FastObjects Database Components Features in Detail, Page 9 Reliability and No Maintenance Your application is running at several customer locations. Not everyone has a database administrator on staff. Especially in times of tight budgets, maintenance expenditure has to be kept low. Whether it’s a matter of hardware errors or new versions, your customers are entitled to low-maintenance software. Check Digits Hard drives can also be defective. Or drive controllers can malfunction. Or the network can corrupt a bit. Or a memory overwrite can change the byte stream while reading. FastObjects stores a check digit for every object as a safeguard. This lets us ensure that the content of the object is not changed between write access and read access. Because malfunctions are recognized immediately, your application can react quickly -- with an automatic repair, a switch to an online replicate or use of an earlier data backup. Automatic Recovery Of course databases have to be secure. Even if the plug is pulled in the middle of operations so that the vacuum cleaner can be plugged in. FastObjects is "automatically" secure to a certain extent. Our Recovery Log is always running. When the database is brought up, FastObjects checks the status of the log and automatically puts the database into a consistent state. The user simply has to put the plug back into the outlet. It’s "vacuum cleaner-proof”. FastObjects benefit: Online Database Check The hardware has failed or your software has a pointer error. You want to be sure that the database is still consistent. FastObjects offers an online database check that examines the consistency of the database while the application is running. FastObjects checks the index trees, available memory administration, object consistency and reference completeness. And then repairs any errors. Available Memory Administration So that your database remains compact and fast even after running for some time, FastObjects has an integrated available memory administration function. It registers sectors in the database as they become available, assembles adjacent memory and reassigns it. That keeps your database from coming apart at the seams. Schema Versioning Your application was already good. But the new release is even better. Unfortunately, you have to adjust the data structures, add classes and change data types to accommodate it. The data for hundreds of customers have to be converted. No problem with FastObjects. Our Data Dictionary can handle several class descriptions. Your customer installs the new dictionary and FastObjects recognizes the differences between the old and new class versions and converts the objects: either in batch mode or while the application is running. Read old objects and write new ones. We call that "Versioning on the Fly." FastObjects benefit: Simple Installation In many applications, the problems begin at installation: installation routines for the database, extensive entries in system tables, new driver versions and all kinds of configurations. Not so with FastObjects. We just go along for the ride in a "co-installation”. Your installation program copies our library and executables. You can handle the little bit of configuration with our API – in your installation program. Then your customers won’t have to call support while they’re still in the installation phase. FastObjects Database Components Features in Detail, Page 10 Internationalization and System-Independence Markets are melding together and you want to market your application internationally, regardless of the hardware. You’ll increase turnover. Unicode Strings and Language-specific Sorting FastObjects stores unicode strings and sorts them with lexical correctness, in accordance with ISO-14651. We sort a German "ü" as "ue" and a Spanish "ll" as "j" instead of strictly following the ANSI table. So that your application can be really international, every string can have its own language context. Language and Operating System Independence Your customers have diverse UNIX servers, Windows clients and NT servers too. With FastObjects, you can support heterogeneous networks. The objects are transparently converted into the client’s processor format. The programming language plays no role at all. Java applications can read data written in C++ with no trouble. And vice versa, of course. If you want to switch servers (for example, from Windows to Unix), you have only to copy the database: binary-compatible, language-independent objects. Productivity and Integration in Development Environment To be able to develop productively, you need the right tools. A simple build-process saves time and money. That’s why we’ve integrated FastObjects into all conventional development environments and modeling tools. So that routine work won’t hold you up. UML Tool Integration You develop your class model with UML and that gives you a well thought out design. We’ve integrated FastObjects into Rational Rose so that you can define your database design with UML too. It doesn’t matter if you use C++ or Java ODMG. You can define persistent classes and index descriptions directly in your UML model. Java IDE Integration So that you can build your database and change versions quickly, we’ve integrated FastObjects into Jbuilder and Forte. Our code enhancer is automatically called up at every build-process. It creates the database schema or adjusts to its altered class model. Indices are automatically constructed. You take care of your application while FastObjects looks after your database objects. Visual Database Tools You’d like to look into the database quickly to see which objects have been stored or visualize the database scheme or check database consistency after a system error. For these purposes, FastObjects offers a series of visual tools from object and class browsers to database check tools. Everything is on hand in our Developer’s Workbench. FastObjects Database Components Features in Detail, Page 11 © Poet Software GmbH 2002. Poet®, Poet Software and FastObjects are trademarks registered trademarks of Poet Holdings, Inc. All rights reserved. Java™ and all Java™-based trademarks and logos are trademarks or registered trademarks of Sun Microsystems, Inc. in the U.S. or other countries. Poet Software is independent of Sun Microsystems, Inc. Other product names may be trademarks of the companies with which the product names are associated. Poet Software GmbH Kattjahren 4 - 8, 22359 Hamburg, Germany http://www.fastobjects.com Tel.: +49(0)40 / 60 990 - 0 http://community.fastobjects.com Fax +49(0)40 / 60 990 - 113 eMail: [email protected]