Designing a Low-Code CRUD framework

Nowadays programmers write source code for inserting, editing and deleting records of a relational table. The majority of commercial relational databases include a specific management tool that offers such possibilities and most database programmers take this ability as granted. When it comes to real life applications, programmers use Object Oriented (OO) paradigm to build user friendly windows/screens/forms for database operations. The current work shows a different approach using a Low-code CRUD (Create, Read, Update, Delete) framework. Views and guidelines of how to design a Low-code CRUD framework will be detailed. “Low-code” motivation is due to the fact that the new framework will provide the ability to use less code in order to build fast and efficient complex applications. It will be up to the reader to envision a specific framework.

Optimized execution method for queries with materialized views: Design and implementation

A query application for On-Line Analytical Processing (OLAP) examines various kinds of data stored in a Data Warehouse (DW). There have been no systematic studies that look at the impact of query optimizations on performance and energy consumption in relational and NoSQL databases. Indeed, due to a lack of precise power calculation techniques in various databases and queries, the energy activity of several basic database operations is mostly unknown, as are the queries themselves, which are very complicated, extensive, and exploratory. As a result of the rapidly growing size of the DW system, query response times are regularly increasing. To improve decision-making performance, the response time of such queries should be as short as possible. To resolve these issues, multiple materialized views from individual database tables have been collected, and queries have been handled. Similarly, due to overall maintenance and storage expenses, as well as the selection of an optimal view set to increase the data storage facility’s efficacy, materializing all conceivable views is not viable. Thus, to overcome these issues, this paper proposed the method of energy-aware query optimization and processing, on materialized views using enhanced simulated annealing (EAQO-ESA). This work was carried out in four stages. First, a Simulated Annealing (SA) based meta-heuristic approach was used to pre-process the query and optimize the scheduling performance. Second, the optimal sets of views were materialized, resulting in enhanced query response efficiency. Third, the authors assessed the performance of the query execution time and computational complexity with and without optimization. Finally, based on processing time, efficiency, and computing cost, the system’s performance was validated and compared to the traditional technique.

Transformation of Digital Requirements: An Enabler for Successful Complex Projects

This paper discusses the lessons learned from transforming upstream operational requirements from a document environment into a requirements management tool (database). Operations requirements from upstream practices, procedures, specifications, and guides were migrated from a document centric environment into a requirements management system (data centric). Here, requirements were assigned attributes denoting the organization and accountable operational role that requirement. Many organizations, operating complex offshore procedures, especially where operations are highly regulated, are looking to move their operational requirements from a document centric environment to a data centric environment. This paper highlights some potential pitfalls and mitigation strategies for ensuring a successful migration.

A Natural Logic System for Large Knowledge Bases

This paper describes principles and structure for a software system that implements a dialect of natural logic for knowledge bases. Natural logics are formal logics that resemble stylized natural language fragments, and whose reasoning rules reflect common-sense reasoning. Natural logics may be seen as forms of extended syllogistic logic. The paper proposes and describes realization of deductive querying functionalities using a previously specified natural logic dialect called Natura-Log. In focus here is the engineering of an inference engine employing as a key feature relational database operations. Thereby the inference steps are subjected to computation in bulk for scaling-up to large knowledge bases. Accordingly, the system eventually is to be realized as a general-purpose database application package with the database being turned logical knowledge base.

Empirical Evaluation of NoSQL and Relational Database Systems

Aim: To evaluate the performance of Relational and NoSQL databases in terms of execution time and memory consumption during operations involving structured data. Objective: To outline the criteria that decision makers should consider while making a choice of the database most suited to an application. Methods: Extensive experiments were performed on MySQL, MongoDB, Cassandra, Redis using the data for a IMDB movies schema prorated into 4 datasets of 1000, 10000, 25000 and 50000 records. The experiments involved typical database operations of insertion, deletion, update read of records with and without indexing as well as aggregation operations. Databases’ performance has been evaluated by measuring the time taken for operations and computing memory usage. Results: * Redis provides the best performance for write, update and delete operations in terms of time elapsed and memory usage whereas MongoDB gives the worst performance when the size of data increases, due to its locking mechanism. * For the read operations, Redis provides better performance in terms of latency than Cassandra and MongoDB. MySQL shows worst performance due to its relational architecture. On the other hand, MongoDB shows the best performance among all databases in terms of efficient memory usage. * Indexing improves the performance of any database only for covered queries. * Redis and MongoDB give good performance for range based queries and for fetching complete data in terms of elapsed time whereas MySQL gives the worst performance. * MySQL provides better performance for aggregate functions. NoSQL is not suitable for complex queries and aggregate functions. Conclusion: It has been found from the extensive empirical analysis that NoSQL outperforms SQL based systems in terms of basic read and write operations. However, SQL based systems are better if queries on the dataset mainly involves aggregation operations.

Implementing Query Terms Linked to Virtual Databases by Metaheuristic Techniques

In general case, the database trigger may be quite applicable to signified queries to validate the database requests. Specifically, these may be essential to adopt search mechanisms to identify the query terms. In such cases it may also be required to eradicate ambiguities during updates by checking consistencies, durability. Many database systems support aggregate functions as it may be really linked to statistical analysis of large scale data. Again as per the requirement and schedule, multilevel aggregation may be thought of towards report generation and implementation of join predicates. In case of complexity, direct requests may be accessed to schedule the entire database operations. While optimizing the database queries, alternative query plans may be thought of implementing specific routines to eradicate the duplicity of query terms. It may be quite possible to containerize the query plans linked to several data servers exploring the inter operator parallelism. Also the assemblers linked to the query plans in the servers may steer the process accordingly. Considering the implementation mechanisms of database query plans inside a cloud storage system, the data may be automatically partitioned and replicated. The servers may change dynamically the existing load in response to the query plans. The queries as well as the transactions may be uncommon during optimization process and applications may be communicated following standard activity protocols linked to the database servers. Linking the query terms to the databases, it may also be required to incorporate metadata towards plan execution. Many times transactional database applications linked to relational cloud may have the provision of configuring and accessing the data and may face the challenges like scalability and privacy. To overcome these issues, the tasks may be relocated and rearranged linked to database servers by which better performance may be achieved dealing with complex transactions. Also the aggregation methods or techniques linked to data partitioning may enable the structured queries to yield better performance. In this paper it is intended to obtain query terms along with the threshold values linked to virtual databases.