A novel data storage logic in the cloud

Introduction

Databases which store and manage long-term scientific information related to life science are used to store huge amount of quantitative attributes. This is specially true for medical databases^1,2. One major downside of these data is that information on multiple occurrences of an illness in the same individual cannot be connected^1,3,4. Modern database management systems fall into two broad classes: Relational Database Management System (RDBMS) and Not Only Structured Query Language (NoSQL)^5,6. The primary goal of this paper is to introduce a novel database model which provides an opportunity to store and manage each input data in one (physical) data table while the data storage concept is structured. JT can be defined as a NoSQL engine on an SQL platform that can serve data from different data storage concepts without several conversions.

Methods

The technical environment is Oracle Application Express (Apex) 5.0 cloud-based technology. Workstation: OS (which is indifferent) + internet browser (Chrome). The Joker Tao logic (www.jokertao.com) can be applied in any RDBMS system (e.g. www.taodb.hu). Specification of the physical data table structure was determined with -ID (num) as the identifier of the entity, which identifies the entity between the data tables (not only in the given data table); -ATTRIBUTE (num) is the identifier of the attribute; -SEQUENCE (num) which is used in the case of a vector attribute; and -VALUE (VARCHAR2) which is used for storing values of the attributes. The codes which are stored in the Attribute column are also defined, sooner or later, in the ID column. At that time the attribute becomes an entity. In every case, the subjectivity determines the depth of entity-attribute definition in the physical data table. Firstly, we demonstrate a traditional (relational) data table structure (Table 1).

Following this, the presented data table has been modified step by step. At the end of these steps, the JT data storage structure is created. The first step is the technical data storage. In Table 2, technical data will be stored which describes exactly what the virtual data table stores in the physical data table.

In the second step, the identifiers assigned to the attributes are displayed (Table 3).

In the third step, identifiers assigned to the entities are also displayed (Table 4). These identifiers are assigned to each cell of the entity. These identifiers are determined by the developer. The values of these identifiers can be any natural number that has not already been used in the ID column.

In the fourth step, the attribute identifiers are also assigned to each cell (Table 5). These identifiers are determined by the developer. The values of these identifiers can be any natural number that has not already been used in the Attribute column.

In the fifth step, the initial value of the cell is inserted as the Value of the JT structure (Table 6). From this stage, the developer uses identifiers (which were defined in the previous steps) instead of attribute names.

The final step is to rotate the traditional data table structure 90 degrees. This means each virtual data table is defined in one physical data table. With these steps the developer can design one data table to store each entity, attribute and formula in a database. The above described method can be applied manually. For the automatic conversion we created a Java code below⁷:

public static String getEntityName ( )
throws Exception
{ 
Connection conn = broker.getConnection ( );
PreparedStatementpstmt = 
conn.prepareStatement ("select * from joker"); 
ResultSetrs = pstmt.executeQuery ( );
inti = 0; 
while (rs.next ( )) { 
i++; 
} 
System.out.println ("number of records:" + i ); 
broker.freeConnection (conn); 
return ""; 
} 
public static void insert JokerRow 
(Integr GROUP_ID, Integer UNIQ_ID, 
Integer FIELD_ID, Integer ARRAY_INDEX,
String SEEK_VALUE, String FIELD_VALUE)
throws Exception { 
if (GROUP_ID == null) pstmt.setNull (1, 2); 
else pstmt.setInt (1, GROUP_ID.intValue ( ));
if (UNIQ_ID == null ) pstmt.setNull (2, 2);
else pstmt.setInt (2, UNIQ_ID.intValue ( )); 
if (FIELD_ID == null ) pstmt.setNull (3, 2); 
else pstmt.setInt (3, FIELD_ID.intValue ( ));
if (ARRAY_INDEX == null ) pstmt.setNull (4, 2); 
else pstmt.setInt (4, ARRAY_INDEX.intValue ( )); 
if (SEEK_VALUE == null) pstmt.setNull (5, 12); 
else pstmt.setString (5, SEEK_VALUE); 
if (FIELD_VALUE == null) pstmt.setNull (6, 12); 
else pstmt.setString (6, FIELD_VALUE); 
pstmt.execute ( ); 
} 
public static void readFile ( ) throws Exception 
{ 
File f = new File ("data.txt"); 
BufferedReaderbr = new BufferedReader 
(new FileReader (f )); 
while (br.ready ( )) { 
String line = br.read Line ( ); 
int GROUP_ID = Integer.parseInt
(line.substring (0, 10 )); 
int UNIQ_ID = Integer.parseInt 
(line.substring (11, 21)); 
int ARRAY_INDEX = Integer.parseInt 
(line.substring (22, 32)); 
String FIELD_VALUE = line.length ( ) > 32? 
line.substring (33, line.length ( )): " "; 
insertJokerRow (Integer.valueOf (GROUP_ID), 
Integer.valueOf (UNIQ_ID), null, 
Integer.valueOf (ARRAY_INDEX), null, FIELD_VALUE); 
} 
br.close ( ); 
}

Results

The resulting table structure is called JT structure (Table 7).

From the JT physical data table, the following definitions can be read out:

Thesis: In the JT structure, each attribute needs only one index for indexing in the database.

Proof using mathematical induction: It is obvious the statement is true for the case of one record stored in a data table (according to the RDBMS structure where the developers use more indexes to indexing more attributes). In this case the data table appears as shown in Figure 1.

Figure 1. Indexing a record.

                          Index = attribute (num) + value (varchar 2)

In view of entity, an ID (numerical) index is also used in JT logic-based systems. This ID does not depend (no transitive dependency) on any attribute. Thus, the entities of the virtual data tables meet the criteria of the third normal form (Figure 2).

Figure 2. ID usage.

The modes of the expansion of a data table are: -input new entity (Figure 3); -input new attribute (Figure 4); -input new virtual data table (Figure 5).

Figure 3. New entity.

Figure 4. New attribute.

Figure 5. New virtual data table.

The indexing is correct in case of n+1 record expansion also. With JT logic the user is able to use only one physical data table to define each virtual data table in a database. Therefore, since only one index is required to index each attribute, the statement of the thesis is true in every case of the JT logic-based data table according to the principle of mathematical induction below. Thesis: For n=1 ergo;

substituting one into the equation we get:

result of the operation is 1=1, that is, the induction base is true.

Using proof by induction we can now show that this is true for the following equation:

n = k where k is a optional but fixed natural number. Therefore, we know that the following operation is true:

Finally using n=k+1 we can prove our assumption to be true:

The above induction proof shows:

Conducting the mathematical operations we obtain the following:

Conducting the mathematical operations on the other side we obtain the same:

Thus, the induction step is true. Given that both the induction base and the induction step are true, the original statement is therefore true. In the present study, we explained the JT data storage logic. In our other study we focused on the query tests. Our previous results⁷ show that from 10000 records the relational model generates slow (more than 1 second) queries in a cloud-based environment while JT can remain with the one second time frame.

Discussion and conclusions

Using the developed database management logic, each attribute needs only one index for indexing in the database. JT allows any data whether entity, attribute, data connection or formula, to be stored and managed even under one physical data table. Thanks to this flexibility, a formula which is stored in a database can be utilized for problem solving in another field regardless of the difference in data storage method used in the present environment. In the JT data model, the entity and the attribute are used interchangeably, so users can expand the database with new attributes after or during the development process. With JT logic, NoSQL engine is ensured in SQL database systems for the storage and management of long term scientific information.