Switch to: V10V9V8V7V6V5

Valentina DB Features

Features integrated into the Valentina kernel or into required components. Here you can find all advanced features.

Design

100% Self-Contained - Valentina has Application Developer Kits (ADKs) for different APIs which are 100% self-contained object-relational database management systems. Valentina does not require additional middleware to or data connectivity drivers such as Jet, BDE, ODBC or MDAC.

Single-User and Client/Server Supported You can develop applications that can manage local databases, as well as develop client applications to Valentina Server as a remote database. You can even use both modes at the same time.

Cross-Platform Valentina DB is a cross-platform, multi-operating system database. Implementations are available for

  • Windows
  • macOS
  • many distributions of Linux

32 and 64-bit versions Valentina engine exists in both 32 and 64-bit versions for different products.

Cross Data Model - Valentina can use multiple data models, including:

  • Relational data model;
  • Object-Relational data model;
  • Next generation Navigational data model, which is beyond the one in e.g. dbVista and Raima products.
  • KeyValue Store
  • NoSQL
  • SQL

SQL92+ Standard - Valentina SQL is SQL92 compliant and supports elements of SQL99/SQL2003. Valentina SQL also includes Valentina extensions to utilize special features of Valentina technology. [read more about Valentina SQL...]

Speed - Database vendors like to say they are fast. Valentina Server provides truly ground-breaking performance, beating most of the mature and popular database servers from most database vendors (MSSQL, Oracle, Access, mySQL, Postgre, FileMaker, 4D, …). Average speed performance varies from at least 3-5 times and up to 10-100+ times depending on a query, db structure and data.

[see customer testimonials about Valentina speed...]

Deployment

Easy Deployment - Valentina makes deployment of your applications incredibly easy. No need for special registration on the target computer. Valentina-enabled applications can even run directly off of read-only media like CD and DVD or flash media.

Cost-Effective - Build and deploy Valentina applications royalty free. You can purchase developer solutions once, develop unlimited numbers of applications and sell unlimited deployments of your applications - royalty free. [Read more about Valentina Licensing...]

Flexible Engine API

Valentina API provides for practically all supported languages and IDEs few hundreds of methods to control the database engine functionalities.

You get a set of high and low-level capabilities. High-level functions let you accomplish a lot in a single function call while low-level functions give you advanced, granular control over your application and database.

Easy to Learn The Valentina API, because of its modular well organized object-oriented design, utilizes intuitive, natural class and function names.

SQL API - Uses a set of classes and methods which provides high-level API to manage database via SQL. Your experience with any technology that utilizes SQL such as ADO will help you to get started.

Valentina Native API - is the rich set of classes and methods which provides low-level API to features of the engine and allows to execute any database task without SQL at all.

You are not limited to a single API or data model: you can easily mix them within your code. [Read more about code styles and Valentina...]

Maximal Capacities

Parameter Max Capacity
Database size Terabytes.
Number of Tables in database 2 billions
Number of Fields in Table 2 billions
Record Size Unlimited
BLOB Size 2 Gb per record

Data Storage

Single Database File - Valentina database can be stored in a single disk file (volume). It has an internal file system to keep many logical files inside. Actually, Valentina allows you to choose how to keep data of database using 8 modes to split data into few disk files such as schema, data, index, blobs and temporary volumes. [read more...]

In-memory Databases and Tables - Valentina supports creating and managing in-memory databases and in-memory temporary tables (while you work with the disk-based database).

Temporary Tables - Valentina can create temporary disk-based tables that will be stored on disk but in the separate TMP volume. Therefore in case of failure, your schema and data are not affected.

Temporary Fields - Valentina has a unique ability to create an additional temporary field for a disk-based table. Such field is not stored in the Schema and puts its data into the separate TMP volume. Therefore in a case of failure, your schema and data are not affected.

System Tables - Valentina allows you to have your own SYSTEM Tables. read more....

Alter Schema Having Records - Valentina allows you to alter the structure of a Table even if it has some records. If you change the type of a field then Valentina convert data into the new type using natural conversion rules.

Row Level Locks - Valentina provides true record-level locks.

Encryption - Keep your customer data safe! Strong 448-bit BlowFish encryption on entire databases, or just some tables and/or fields. Also, you can encrypt structure of the database to prevent its opening by other Valentina GUI tools. [read more...]

BLOB compression - BLOB data can be compressed saving disk space. Applied to the TEXT fields (which are kind of BLOB) this is especially useful because allows having compressed TEXT values still being indexed.

Advanced Cache Management - ValentinaDB has a sophisticated cache that reduces disk access increasing, therefore, performance of operations.

Journaled - ValentinaDB uses the journal to implement atomic commit and rollback capabilities.

Field Types

True Bit Type - Valentina is practically the only DBMS on the market that offers you filed which really uses 1 bit per record (other dbs, in the best case, packing bits into a byte).

Numeric Types - Valentina has a very rich set of numeric types: Byte, Short, UShort, Medium, UMedium, Long, ULong, LLong, ULLong, Float, Double.

Date/Time Types - Valentina has effective types for date and time values: Date, Time, DateTime, Interval.

String Types - Valentina has few types to keep strings:

  • String - fixed size strings;
  • VarChar - variable size strings;
  • Text - unlimited size strings;

Binary Types - Valentina has 3 types to keep binary data: FixedBinary, VarBinary, and BLOBs. BLOB can be compressed to reduce disk usage in 5-10 times disk space.

Picture Type - Valentina has a special Picture Field that can compress bitmaps into JPG/TIFF formats. This again allows you to save a lot of disk space.

RecID - Each Valentina Table has a RecID field - that means automatic unique id for a record in the scope of a Table. It uses ZERO space on disk! [read more...]

OID - Each Valentina Table has an OID field - it provides the unique ID of a record in the scope of the database as required by ODMG Standard. It also uses ZERO space on disk! [read more...]

Pointer Types - Valentina have unique feature Pointer field types: ObjectPtr and ObjectsPtr.

  • ObjectPtr is kind of direct pointer, as you can find in Network Model. Works up to 4 times faster of similar Foreign Key link on joins. Uses significantly less disk space then Foreign Key model. [read more...]
  • ObjectsPtr field is not implemented currently.

ENUM Type - allows you to specify set of strings mapped to numeric constants, which are saved into a file. Valentina-DB allows you provide localized sets of strings! [read more...]

VARIANT Type - field type that allows you save ANY value from bool to BLOB. [read more ...]

Unicode and Text

Unicode - Valentina uses the power of the IBM ICU Unicode library providing support of the advanced set of string operations for UTF16, UTF8 and any of 200+ encodings.

RegEx Search - Uses Regular Expression search capabilities of Valentina to offer your users advanced features.

Full Text Search Valentina can index String/VarChar/Text fields by words. Also, you can apply IndexStyle to such index to provide IgnoreWords list and maxLengthToIgnore.

Locale - Valentina uses IBM ICU library as a core engine for work with Unicode. ICU is the best Unicode library, it is used even in Mac OS X. Valentina is designed to open maximal power of ICU to database developers. [read more...]

Locale Inheritance - You can specify Locale to a Da32tabase, Table, and separate Field. In most cases you will use just database level, tables and fields will inherit settings from the top level. Ability to set different locale settings for tables and fields gives you a perfect way to create multi-language databases. [read more...]

With Valentina, you have an incredible set of locale settings you can control. For example, you can specify if an index should be case-insensitive, accent-insensitive or not if strings should be considered as numbers, and so on. You can configure 8 parameters of the Locale.

Table Methods

Valentina allows you to create a Table Calculated Fields, also known as Table Methods. Such field does not store its values on the disk, but calculate them dynamically by some expression. [read more...]

Calculation Functions

Valentina has rich set of functions (about 100) to be used in SQL expressions, CHECKs and Table Methods (aka Calculated Fields). Valentina provides such groups of functions:

New Abstraction "Link"

Valentina offers a new Object-Relational abstraction LINK which elegantly extends the FOREIGN KEY feature, which is just a CONSTRAINT in the Relational Model.

Valentina offers currently 3 kinds of links between tables:

Link Refactoring Valentina provides special API and SQL methods to allow easy refactoring (conversion) of links.

Constraints

A Constraint validates data entry. Valentina supports the Field and Table-level constraints such as

  • UNIQUE
  • CHECK
  • PRIMARY KEY
  • FOREIGN KEY

FOREIGN KEY constraint provides the referential integrity of kind:

ON DELETE: {RESTRICT, SET NULL, CASCADE, DEFAULT}
ON UPDATE: {RESTRICT, SET NULL, CASCADE, DEFAULT}

ObjectPtr Link and Binary Link provides the referential integrity of kind:

ON DELETE: {RESTRICT, SET NULL, CASCADE}

Indexes

Valentina uses several types of indexes to manage different types of fields in the most effective way.

Bit Field Index - is so 'perfect' that it even doesn`t exist on disk.

Byte Index - special kind of index for a BYTE field.

Unique Index - index optimized for a UNIQUE field. [read more...]

Not Unique Index - index for a not unique field (the most general case). [read more...]

Index by Words - index that split values of String/VarChar/Text fields on words. Supports full text editing. [read more...]

Index by Expression - while SQL standard supports only syntax “CREATE INDEX (f1,f2,f3)” meaning just concatenation of values of few fields, with Valentina you can get indexes by any complex expression using Table Methods. You can create, for example, an index based on:

  • part of a field
  • expression based on a field
  • expression on few fields

Hash Index - the index is based on the hash of original value. Such index is much smaller and is a good choice e.g. for PK and/or UNIQUE columns.

Multi-Column Index - index is based on combination of values from few columns. [read more...]

Read More About Indexes...

Data Exchange

Text Import/Export - Import/Export your data from/to text files. You can control both fields and record delimiters. The text file can be in UTF-8, UTF-16 or any other encoding.

XML Import/Export - Supports high-speed importing and exporting from/to XML files of Valentina data, including schema only, records only or both. Files can be in UTF-8, UTF-16 or any other encoding. Dump can be for the whole database or separate table.

SQL Dumps - Supports high-speed dumping to SQL dumps and loading from SQL dumps of Valentina data, including schema only, records only or both. Files can be in UTF-8, UTF-16 or any other encoding. Dump can be for the whole database or a separate table.

ODBC Import/Export - using Valentina Studio's ODBC Import/Export.

SQL

Valentina SQL is SQL92 compliant, supports some elements of SQL99/SQL2003 plus Valentina extensions. [read more...]

SQL Optimizer - Valentina has powerful SQL optimizer which does the job on few levels. For example, it can transform query tree to make it optimal, select best join path, select best algorithms for given data and structure.

Pool of Queries - Valentina SQL engine keeps the pool of last executed queries. In case engine sees that a new query is a byte to byte the same as the one from the pool, it just uses existed tree of that query. To use this feature you should use SQL-binding of values as much as possible to have the same query string.

EXPLAIN - Valentina has an ability to explain the path of execution of your SQL query. This also shows how much time each of sub-tasks (profiling) has eaten, so you can easily determinate where is a bottleneck.

Standard SQL Commands

  • CREATE/DROP/ALTER TABLE, DROP TABLE
  • CREATE/DROP/ALTER LINK
  • CREATE/DROP/ALTER VIEW
  • CREATE/DROP/ALTER TRIGGER
  • CREATE/DROP PROCEDURE
  • CREATE/DROP FUNCTION
  • CREATE/DROP USER
  • GRANT/REVOKE PRIVILEGES
  • DECLARE/OPEN/CLOSE CURSOR
  • FETCH NEXT/PRIOR/RELATIVE/ABSOLUTE
  • LOOP/REPEAT/WHILE
  • LEAVE/ITERATE
  • IF/CASE
  • SET var = EXPR
  • EXECUTE [WITH PARAMETERS var1,…]
  • PRIMARY KEY and FOREIGN KEY
  • UNIQUE, CHECK Constraints, IDENTITY
  • INSERT … VALUES()
  • INSERT … SELECT …
  • UPDATE … WHERE …
  • DELETE … WHERE …
  • LINK/UNLINK
  • SELECT .. WHERE .. GROUP BY … HAVING … ORDER BY …
  • DISTINCT COUNT MIN MAX SUM AVG STDDEV …
  • INNER JOINs
  • OUTER (LEFT/RIGHT/FULL) JOINs
  • Qualified JOINs
  • Implicit JOINs
  • UNION, EXCEPT, INTERSECT with ALL or column match list
  • Sub-Queries including correlated.

Valentina SQL Extensions

  • CREATE/DROP/USE DATABASE
  • BACKUP/CLONE DATABASE
  • CREATE/DROP/USE PROJECT
  • BACKUP/CLONE PROJECT
  • REGISTER/UNREGISTER DATABASE
  • REGISTER/UNREGISTER PROJECT
  • CREATE/DROP/ALTER EVENT
  • DROP CONNECTIONS
  • COMPACT/DEFRAGMENT
  • DIAGNOSE DATABASE/TABLE/FIELD
  • REINDEX DATABASE/TABLE/FIELD
  • PIVOT table
  • WITH syntax - “view on one query”
  • GROUP BY … WITH ROLLUP
  • SELECT … FOR XML [RAW|AUTO] [,] [ELEMENT | ELEMENTS] [ [WITH|USE] CDATA ]
  • SELECT … FOR REPORT project_name.report_name [AS {PDF|HTML|JGP}] [PAGES start_page TO end_page]
  • SELECT … FOR JSON
  • SET/GET PROPERTY
  • SHOW DATABASES/COLUMNS/EVENTS/LINKS/PROCEDURES/PROPERTIES/TABLES/TRIGGERS/PROJECTS/VKEYWORDS/VIDENTS
  • SHOW STATUS OF SERVER/DATABASE/TABLE/FIELD/LINK/INDEX/ENGINE

Links:

  • CREATE BINARY LINK
  • ALTER LINK
  • DROP LINK
  • LINK/UNLINK RECORDS
  • COPY LINKS
  • ANCESTORS/DESCENDANTS/BROTHERS OF {UINT|Var|search_condition} [{TO|ON} LEVEL UINT}] USING link_name [WITH ROOT]

KeyValues:

  • CREATE KEYVALUE kv_name
  • CREATE KEYVALUE kv_name OF TABLE tbl_name
  • CREATE KEYVALUE kv_name OF LINK link_name
  • DROP KEYVALUE
  • KEYVALUE kv_name [INSERT | UPDATE | UPSERT ] …
  • KEYVALUE kv_name GET [LIKE] (key_list)
  • KEYVALUE kv_name DELETE [LIKE] (key_list)
  • SHOW KEYVALUES

Diagnostic Tools

Warning Log File - is a log file that collects information about not fatal errors during work of engine. [read more...]

Tune Log File - is an optional log file that collects information about profiling of SQL commands which allows you to see a bottleneck in your SQL queries and improve them. [read more...]

Cleanup Database Features

COMPACT - cleanups unused space in database files as much as possible [read more...]

DEFRAGMENT - defragments any logical fragmentation in the file structures. This can be chain of segments of the logical file, chain of segments of BLOB record, pages in the page files as VarChar and Indexes. Defragmentation usually increases performance. [read more...]

DIAGNOSE - Valentina has a powerful multi-level diagnose feature, which can check everything in the database up to indexes and produce textual report. [read more...]

DB Schema Refactoring Features

CLONE - this feature allows you to clone an existed database into the new one. You can clone structure only or the structure with records.

LINK REFACTORING. Valentina provides SQL and API commands that allow easy refactor of existing links between different data models. For example, you can easily convert Foreign Key link into ObjectPtr link.