Free rdbms software for windows

DB Mail Director - sometimes it is necessary to create and send a set of e-mail messages, but each of these messages differs from any other one only in some details. It can happen e.g., when you want to wish Merry Christmas all of your customers or partners. On the other hand there is a database (or it is easy to create one) with your partners information. In the above situation the best and useful variant is to use a software such as DB Mail Director.
First of all you should create a message template which includes special tags. Such tag contains either a field name from the existent database or a logical expression with Boolean field, any other field and static text. For one the letter template may begin with such string: "Dear {{PARTHNER_NAME_USE ? PARTHNER_NAME : [[Sirs]]}}!". So, for data row which field "PARTHNER_NAME_USE" is true and field "PARTHNER_NAME" is "Mr. Jackson" the message begins with string "Dear Mr. Jackson!" but if "PARTHNER_NAME_USE" = false the first line will be "Dear Sirs!".
The template may be used also for creating any other message parameters. Usually the parameter "Send To" will be "{{PARTHNER_MAIL}}" or something like this. User has a possibility to define any Boolean field to indicate that for this row the message should be sent, as well as there may be a field which contains time of row creating, modifying and last message sending. Of course user interface allows created message previewing. A message template text can be written not only as plain text but also as text in Rich Text Format (HTML).

UploadBean 1.9 is a freeware JavaBean designed to help you upload files from browser. This bean could be integrated in any JSP/Servlets application. You can store uploaded files in a Folder, a ZIP archive, a Database or in Memory.
Restrictions such as file size limit, blacklist/whitelist and max. uploaded files are available. You can also be notified when on upload events. UploadBean is free for non-commercial use.
Add-ons section provides tools such as email notification on each uploads, real time progress bar on upload, custom database store sample, renaming plugin, chinese upload jsp sample, JSF plugin ...
Main features:
- Engines :
UploadBean should work under any Servlet2.2/JSP1.1 engine (or higher). It has been validated under Tomcat 3.x, Tomcat 4.x, Tomcat 5.0.x, Tomcat 5.5.x, JRun 3.1, JRun 4.0, Resin 2.0.5, Resin 2.1.x, WebSphere 3.5.3, WebSphereAE 4.0.3, WebSphere 5.x, Weblogic 6.1, Weblogic 7.0, SunONE 7, ServletExec 4.1, Orion 1.5.4 ... More info here.
- Databases :
UploadBean could store uploaded files in database. It should work under any RDBMS supporting large column or blobs. It has been validated under Oracle8i, Oracle9i, IBM DB 7.2, PostGreSQL 7.3, OpenBase 8, MySQL 3.23.x, SQLServer 2000 and MySQL 4.x. More info here.
- Samples and Guides :
UploadBean package includes JSP samples to let developers understand quickly how to use the component. A developer guide is also included for basic usage (methods, scope, tips ...).
- Documentation :
In addition to samples and guides, UploadBean package includes an UML class diagram to let developers know how we designed the component. The JavaDoc is available too.
- Add-ons :
You could find a chinese upload jsp sample, an email notifier for uploads, an upload progress bar and a database store implementation allowing Oracle blob support.

DataObjects.NET is a useful and reliable .NET library which dramatically simplifies development of data and business tiers of the database application. It provides:
Methodology that standardizes and simplifies development of persistent classes and services operating with them providing very clear separation of your business and data tiers from other parts of an application. Essentially DataObjects.NET requires you to build a hierarchy of your persistent and business objects over two base classes: DataObject and DataService. It provides more then 20 attributes controlling almost any persistence or behavior-related aspect. Dont worry about this number - you can know nearly 5 of them to start using DataObjects.NET.
Persistence framework handling all object persistence related tasks transparently. Moreover, this framework allows to almost forget that the underlying database exists - it handles even database schema updates. This framework fully supports inheritance, persistent interfaces, relations and collections, object queries, full-text indexing and search, multilingual properties and a lot of other features. Use of this framework makes most part of your data tier automatically compatible with Microsoft SQL Server 2005 2000, MDSE 2000, Microsoft Access, Oracle, Firebird (formerly - Interbase), MaxDB (formerly - SAP DB) (free, but one of the most featured database servers) without any additional code.
Transactional services allowing to almost forget that your business and data objects operate in the concurrent transactional environment. Transactional services intercept calls of your business tier methods and wraps them into transactions (outermost or nested) providing that if exception or deadlock occurs, no data will be changed. These services are capable of re-processing method call on deadlock exceptions (and similar). This behavior is provided completely transparently for developers, but nevertheless its highly configurable.
Security system supporting per-instance access control lists (allow-deny lists), permissions (custom permissions), security principals (users and roles) and permission inheritance. Its primary goal is to make usage of business objects completely safe, even when these objects are publicly available - via .NET Remoting, for example.
All is initially remotable - any persistent object or business service can be marshaled to another application domain via .NET Remoting (as well as all other DataObjects.NET-related objects, e.g. Query). This means that you can access your data and business tier from a completely different network or across the Internet with almost no additional code. DataObjects.NET supports two marshalling scenarios: access-by-reference for regular DataObjects and by-value marshalling for so-called offline entities (data transfer objects).
Main features:
- Transparent persistence: you dont need to write data access code for insertupdatedelete operations - DataObjects.NET persists instances transparently for you. This means that you should never think about invoking a SaveLoad-like methods also - DataObjects.NET handles such tasks completely transparently making you fell youre working with ordinary object instances. Transparent persistence has similar benefits as automatic garbage collection - you shouldnt worry about persisting your changes. Note that this doesnt mean all changes are persisted immediately - DataObjects.NET optimizes the update sequence (see delayed updates feature description)
- Automatic database schema buildingupgrading (database schema includes tables, views, columns, indexes, etc.): on each startup of Domain its database can be upgraded to support new persistent model (persistent model changes e.g. when you modify, add or delete some persistent classes). Upgrade process doesnt destroy existing data.
- Instance identification: DataObjects.NET uses unique 64-bit integers in the database scope to identify instances; upcoming versions will support GUID and 32-bit integers also.
- Querying: use DataObjects.NET query language (see Query description) or perform a direct SQL query (see SqlQuery description) to select the instances youre interested in. An example of DataObjects.NET query: "Select Animal instances where {LegCount}=4 order by {Name}" - this query fetches all four-legged Animal instances, as well as instances of Animal descendants - e.g. Cats and Dogs). More difficult example selecting grandparents instances: "Select Animal instances where {Children[{Children.count}>0].count}>0". DataObjects.NET query language supports sub-queries, joins, distinct and full-text search part in criteria.
- Inheritance support: as it was mentioned, DataObjects.NET fully supports inheritance for persistent classes. But we went much further here: DataObjects.NET supports so-called persistent interfaces. This unique feature allows you to query for objects implementing some interface and refer to its persistent properties inside query criteria.
- Highly configurable persistence for instance properties:
- Multilingual properties (unique feature): you can mark any property with [Translatable] attribute to specify that it should store independent versions of its value for each Culture registered in you Domain. This and a set of other features dramatically simplifies development of multilingual database applications
- References: dont worry about loading referenced objects, as well as persisting them properly - just write a code like cat.Parent = grandCat. Note that if youll try to delete the grandCat instance after executing this code, cat will be notified (because it holds a reference to grandCat). Also after grandCat deletion cat.Parent will be automatically set to null
- Collections: cat.Children.Add(kittyCat). Paired collections and reference properties (unique feature) are supported (so kittyCat.Parent can be automatically set to cat for the code above). "Contained" collections and references are supported as well (if cat.Children is marked by [Contained] attribute, all instances referenced by Children collection will be deleted on cats deletion)
- Structs: any struct type can be used as type of persistent property or item of collection. DataObjects.NET persists such properties into multiple database columns according to the structure of struct type.
- [Serializable] properties: properties which type is marked by [Serializable] attribute are persisted without any additional coding - theyre stored as byte streams (BLOBs). DataObjects.NET handles references to other persistent entities inside such serialized graphs in a special way making them to point to appropriate instances on each deserialization (note that DataObjects.NET is transactional, so you can find different versions of the same persistent instance in different sessions)
- SQL-related attributes are available for almost any type of persistent properties ([SqlType], [Length] and similar ones)
- Indexing: you can apply [Indexed] attribute to a persistent property to tell DataObjects.NET that an index should be created on it, or use [Index] attribute to describe a compound index
- Full-text indexing & search (unique feature): DataObjects.NET supports full-text indexing and search. Microsoft Search (available for SQL Server 20052000 only) and DotLucene (free, RDBMS-independent) full-text indexing and search drivers are shipped with DataObjects.NET. Built-in managed wrapper for Microsoft Index Service filters helps to index almost any documentfile type stored in database or externally. In particular, you can index the following document types: Microsoft Office files (.doc, .dot, .rtf, .xls, .ppt, etc...), HTML files (.htm, .html), Adobe PDF files and so on.
- Built-in NTFS-like security system (unique feature): DataObjects.NET has extremely powerful security system allowing to define the permission for any action (e.g. method execution or property access), grant or deny it for a set of security principals (users and roles) on some persistent instances (like on folders in NTFS) and enforce its presence by demanding it inside methods or property assessors of persistent types or DataServices. It brings NTFS-like security into your business tier with almost zero additional coding!
- We want to underline two very important features of this subsystem:
- Performance: security system is extremely fast - all passed permission demands are cached, effective permission sets for any cached DataObject instance are cached too, internal security notification layer allows any cached DataObject instance to notify all dependent cached instances on changes in its effective permission set... Normally a subsequent permission demand on the same instance is quite fast. This allows DataObjects.NET to execute up to 4000000 permission demands per second on 2,8GHz P4! Its almost impossible to implement a security system having the similar features and performance without implementing all other caching features DataObjects.NET has. Just imagine the nightmare of implementing the similar part in your DAL!
- Immediate effect: all security restrictions take effect immediately on any security-related changes in Session - so its not necessary to reopen Session invoke some method to apply new security restrictions. When you adding a User to some Role, granting permission for him or for some role it belongs to, this immediately affects on its security restrictions in the current Session - so all is transparent even in this case. Even rollback of nested transaction (or rollback to savepoint) immediately affects on security restrictions.
- Rich data import and export capabilities:
- Serialization: DataObjects.NET completely supports .NET Serialization, so you can serialize or deserialize a graph with persistent instances using binary or SOAP formatters. Custom formatters are supported as well.
- Adapter component exports persistent instances to DataSet and imports back the changes
- Offline layer provides advanced implementation of well-known DTO (Data Transfer Object) pattern. It allows to export a set of DataObject instances to serializable, marshal-by-value ObjectSets, pass them to the client to operate with them locally and propagate the changes made to them back to the application server
- BindingManager component (unique feature) establishes two-way bindings between ASP.NETWindowsForms controls and object properties. It brings Property-PropertyEditor bindings in contrast to common Property-ControlProperty bindings - we think this approach is also interesting for developers
- All importexport tools support VersionIDVersionCode validation (optimistic updates)
- Versionizing provides an ability to "see" the database at any previous state (point in time). This feature works only if its turned on for the whole Domain. Currently Versionizing is supported by SQL Server 2005 2000 driver only.
- Automatic transactions (unique feature - it quite differs from standard COM+ automatic transactions, read more about it further): DataObjects.NET is completely transactional. It supports automatic transactions (started with a method call or property access and committed or rolled back based on result; transactional behavior is controlled by attributes) as well as manual transactions (you can also start/commit/rollback a transaction manually); nested transactions and savepoints are also supported.
- Transparent deadlock handling (unique feature): in a highly concurrent environment deadlocks are regular. In case of a deadlock one of the deadlocked transactions (deadlock victim) is aborted by the database server. Normally it should be re-executed later by the application - this situation is called "deadlock handling". DataObjects.NET is capable of handling deadlocks transparently - if a deadlock occurs during an automatic transaction, it can be transparently handled by re-processing of the outermost transaction (re-calling of corresponding method).
- Data services (unique feature) allows to use all DataObjects.NET transactional capabilities (automatic transactions, transparent deadlock handling) with non-persistent classes (DataService descendants). This feature greatly simplifies development of services operating with persistent instances. Its very convenient to use this conception to develop common services of an application, such as Logging Service. Data services are very close to ServicedComponents of .NET, the difference is that they are much faster (method calls are intercepted by the runtime proxies rather then .NET transparent proxies, no COM+ services are used) and easier to use.
- Runtime services (unique feature) are data services of special type (RuntimeService descendants) that can be periodically executed in a special Thread and Session inside Domain. The purpose of runtime services is to perform various maintenance tasks periodically. For example, all IFtIndexer implementors are runtime services that periodically update full-text indexes.

Mimer SQL Engine 9.1.3c is an application known as a free, fully functional, high-performance RDBMS. It provides ease of use, 24x7 secure operation, full transaction management and compliance with international SQL standards. Mimer SQL also provides scaleable performance including multiprocessor support. Because it is compatible with all major Unix (including Linux), Windows 98/ME/NT/2000 and OpenVMS platforms, Mimer SQL is ideally suited for open environments where interoperability is important.

MicroImages TNT Products 6.9 is a distinguished and tractable geospatial analysis system which offers a complete self-contained integration of a fully featured GIS, RDBMS, and automated image processing system with CAD, TIN, surface modeling, map layout and innovative data publishing tools.

All this capability is available in a single integrated system at one price with an identical interface, functionality, and geodata structure for use on Windows, Mac OS X, Sun Solaris, and popular Linux platforms.

The interface, database text content, messages, map production, and all other internal aspects of TNTmips have been localized for use in 27 languages including Japanese, Chinese, Arabic, Turkish. Thai, Urdu, and all romance languages. The professional version of the TNTmips is in use in over 120 nations while the free TNTlite version (restricted in project size) is used for educational, self learning, and small projects (for example archaeological sites, neighborhood planning, and precision farming).