CN116360776A

CN116360776A - Data processing method and device of low-code development platform and electronic equipment

Info

Publication number: CN116360776A
Application number: CN202310172851.3A
Authority: CN
Inventors: 冷鹏飞; 刘思彦; 刘柏; 范长杰
Original assignee: Netease Hangzhou Network Co Ltd
Current assignee: Netease Hangzhou Network Co Ltd
Priority date: 2023-02-22
Filing date: 2023-02-22
Publication date: 2023-06-30

Abstract

The application discloses a data processing method and device of a low-code development platform and electronic equipment. The method is applied to a low-code development platform, the low-code development platform is associated with an entity, the entity comprises a first attribute and first logic, and a first reference relation exists between the first attribute and the first logic, and the method comprises the following steps: acquiring information of an entity, wherein the information comprises: the method comprises the steps of enabling a first domain-specific language corresponding to an entity, a second domain-specific language corresponding to a first attribute and a third domain-specific language corresponding to first logic; rendering in canvas displayed by a low code development platform according to the information to generate entity nodes corresponding to the entities, first attribute nodes corresponding to the first attributes and first logic nodes corresponding to the first logics; in response to a selection operation for the first attribute node or the first logical node, a first connection line is generated in the canvas for representing the first reference relationship. The method may visually describe a relationship between attributes and logic comprised by an entity.

Description

Data processing method and device of low-code development platform and electronic equipment

Technical Field

The present disclosure relates to the field of software development technologies, and in particular, to a data processing method and apparatus for a low-code development platform, and an electronic device.

Background

In the field of front-end page development, a low-code development platform (LCDP) is a development platform that can quickly generate an application program without code or with a small amount of code. By means of the method for developing the front-end page through visualization, developers with different experience levels can create web pages through a graphical user interface by using a drag component and model-driven logic. In low-code development platforms, data is generally organized and functionally built on an entity (also called a class or a data object) basis. An entity typically includes a plurality of attributes and a plurality of logic. Wherein a reference relationship may exist between the logic and the attribute comprised by one entity and a reference relationship may exist between two different logics comprised by one entity. It is important for a user using the low-code development platform to easily and conveniently obtain the reference relationship between the attribute and the logic included in one entity and configure the attribute and the logic included in the one entity.

In the conventional art, a low-code development platform is provided to describe attributes and logic included in one entity in a tree view. That is, the tree diagram displayed by the low-code development platform provided by the conventional technology can know which attributes and which logics an entity has, but cannot know the reference relationship between the attributes and logics included in the entity.

Accordingly, there is a need for a data processing method of a low-code development platform, which can visually describe a relationship between attributes and logic included in an entity.

Disclosure of Invention

The application provides a data processing method, a data processing device and electronic equipment of a low-code development platform, wherein the method can visually describe the relationship between attributes and logic included in an entity.

A first aspect of the present application provides a data processing method of a low-code development platform, where the method is applied to the low-code development platform, where the low-code development platform is associated with at least one entity, the entity includes a first attribute and a first logic, and the first attribute and the first logic have a first reference relationship, and the method includes: obtaining information of the entity, wherein the information comprises: a first domain-specific language corresponding to the entity, a second domain-specific language corresponding to the first attribute, and a third domain-specific language corresponding to the first logic; rendering in a canvas displayed by the low code development platform according to the information to generate a plurality of nodes, wherein the nodes comprise: the entity node corresponding to the entity, the first attribute node corresponding to the first attribute and the first logic node corresponding to the first logic; generating a first type of connection line in the canvas in response to a selection operation for the first attribute node or the first logical node, wherein the first type of connection line comprises: a first connection line for representing the first reference relationship.

A second aspect of the embodiments of the present application provides a data processing apparatus of a low-code development platform, where the apparatus is applied to the low-code development platform, where the low-code development platform is associated with at least one entity, the entity includes a first attribute and a first logic, and the first attribute and the first logic have a first reference relationship, and the apparatus includes: the acquisition unit is used for: obtaining information of the entity, wherein the information comprises: a first domain-specific language corresponding to the entity, a second domain-specific language corresponding to the first attribute, and a third domain-specific language corresponding to the first logic; the processing unit is used for: rendering in a canvas displayed by the low code development platform according to the information to generate a plurality of nodes, wherein the nodes comprise: the entity node corresponding to the entity, the first attribute node corresponding to the first attribute and the first logic node corresponding to the first logic; the processing unit is further configured to: generating a first type of connection line in the canvas in response to a selection operation for the first attribute node or the first logical node, wherein the first type of connection line comprises: a first connection line for representing the first reference relationship.

A third aspect of the embodiments of the present application further provides a computer readable storage medium, on which one or more computer instructions are stored, where the instructions are executed by a processor to implement a data processing method of a low code development platform according to any one of the foregoing technical solutions.

The fourth aspect of the embodiments of the present application further provides an electronic device, including: a processor; and a memory for storing a data processing program, the server being powered on and executing the data processing method of the low-code development platform as described above after the program is executed by the processor.

It should be understood that the description in this section is not intended to identify key or critical features of the disclosed embodiments of the application, nor is it intended to be used to limit the scope of the disclosed embodiments of the application. Other features of the present disclosure will become apparent from the following specification.

The technical scheme of the data processing method of the low-code development platform, provided by the embodiment of the application, is applied to the low-code development platform, wherein the low-code development platform is associated with at least one entity, the entity comprises a first attribute and a first logic, the first attribute and the first logic have a first reference relationship, and the method comprises the following steps: acquiring information of an entity, wherein the information comprises: the method comprises the steps of enabling a first domain-specific language corresponding to an entity, a second domain-specific language corresponding to a first attribute and a third domain-specific language corresponding to first logic; rendering in a canvas displayed by a low code development platform according to the information to generate a plurality of nodes, wherein the plurality of nodes comprise: the entity node corresponding to the entity, the first attribute node corresponding to the first attribute and the first logic node corresponding to the first logic; generating a first type of connection line in the canvas in response to a selection operation for the first attribute node or the first logical node, wherein the first type of connection line comprises: a first connection line for representing a first reference relationship. In the data processing method of the low-code development platform, corresponding nodes are respectively created for the entity, the first attribute and the first logic included in the entity in the canvas included in the low-code development platform, and a first connection line between the first logic node and the first attribute node is generated in the canvas, wherein the first connection line represents a first reference relationship between the first logic and the first attribute. That is, the method may visually describe the relationship between the attributes and logic that the entity includes.

Drawings

In order to more clearly illustrate the technical solutions of the embodiments of the present application, the drawings that are needed in the description of the embodiments of the present application will be briefly described below, it being obvious that the drawings in the following description are only some embodiments of the present application, and that other drawings may be obtained according to these drawings without inventive effort for a person skilled in the art.

Fig. 1 is a schematic diagram of an application scenario of a data processing method suitable for a low-code development platform provided in an embodiment of the present application.

Fig. 2 is a schematic diagram of the low-code development platform displayed by the server 103 shown in fig. 1 described above.

Fig. 3 is a schematic diagram of a low code development platform provided in the conventional art.

Fig. 4 is a schematic diagram of a data processing method of a low-code development platform according to an embodiment of the present application.

FIG. 5 is a schematic diagram of a low code development platform in the method described above in FIG. 4.

Fig. 6 is a schematic diagram of a data processing method of another low-code development platform according to an embodiment of the present application.

Fig. 7 is a schematic diagram of S620 shown in fig. 6 described above.

Fig. 8 is a schematic diagram of the low code development platform 1 in the method described in fig. 6 above.

Fig. 9 is a schematic diagram of a node in the method described above in fig. 6.

FIG. 10 is a schematic diagram of a canvas of region 2 displayed by the low code development platform 1 in the method described above in FIG. 6.

FIG. 11 is a schematic diagram of a data processing apparatus of a low-code development platform according to an embodiment of the present application.

Fig. 12 is a schematic structural diagram of an electronic device according to an embodiment of the present application.

Detailed Description

In order to enable those skilled in the art to better understand the technical solutions of the present application, the present application is clearly and completely described below with reference to the accompanying drawings in the embodiments of the present application. This application is intended to be limited to the details shown and described, and it is intended that the invention not be limited to the particular embodiment disclosed, but that the application will include all embodiments falling within the scope of the appended claims.

It should be noted that the terms "first," "second," "third," and the like in the claims, specification, and drawings herein are used for distinguishing between similar objects and not necessarily for describing a particular sequential or chronological order. The data so used may be interchanged where appropriate to facilitate the embodiments of the present application described herein, and may be implemented in sequences other than those illustrated or otherwise described herein. Furthermore, the terms "comprises," "comprising," and their variants are intended to cover a non-exclusive inclusion, such that a process, method, system, article, or apparatus that comprises a list of steps or elements is not necessarily limited to those steps or elements expressly listed but may include other steps or elements not expressly listed or inherent to such process, method, article, or apparatus.

For ease of understanding, technical terms that may be involved in embodiments of the present application will first be briefly described.

1, entity

An entity may also be referred to as a class or a data object. One entity includes: at least one attribute and at least one logic. An entity includes attributes that describe what the entity is, and an entity includes logic that describes what the entity can do. Wherein one logic comprises: a logical name, at least one input parameter, at least one output parameter, and a logical body. A reference relationship may exist between logic and attributes comprised by one entity, or a reference relationship may exist between two different logic comprised by one entity. For example, entity 1 includes attribute 1 and logic 1, where logic 1 may reference attribute 1. As another example, entity 1 includes two logics: logic 1 and logic 2, wherein logic 1 may reference logic 2, or logic 2 may reference logic 1.

The structure of one entity is described below by way of example. For example, in the case where entity 1 includes attribute 1 and logic 1, entity 1 may be represented by the following code:

2, domain specific language (domain specific language, DSL)

DSL is a language that abstracts domain-specific operations and concepts in order to solve domain-specific problems. DSL is specific to a particular domain, unlike the general programming language (general purpose language), such as Java or C, which is applicable to both web site development and cell phone development. Once the generic language leaves the relevant domain, it becomes unsuitable. However, for a particular domain, general-purpose languages can naturally and easily represent problems, and often solve problems faster than general-purpose programming languages.

In the field of software engineering, DSL is increasingly being used as requirements and technologies are continuously updated. The following are more common DSLs: HTML for describing Web pages, SQL for database structured queries, CSS for describing style sheets, or BNF paradigm for expressing grammar.

Scalable vector graphics (scalable vector graphics, SVG)

SVG is a graphics format based on extensible markup language (a subset of standard generalized markup language) for describing two-dimensional vector graphics. It is formulated by the world wide web consortium as an open standard.

Hereinafter, an application scenario of a data processing method applied to the low-code development platform of the embodiment of the present application and a data processing method of the low-code development platform will be described in detail with reference to the accompanying drawings. It is to be understood that the following embodiments and features thereof may be combined with each other without conflict between the embodiments provided in the present application. In addition, the sequence of steps in the method embodiments described below is only an example and is not strictly limited.

First, an application scenario of a data processing method applicable to the low-code development platform of the embodiment of the present application is described with reference to the accompanying drawings.

Fig. 1 is a schematic diagram of an application scenario of a data processing method suitable for a low-code development platform provided in an embodiment of the present application. By way of example, the application scenario illustrated in fig. 1 includes a plurality of terminal devices, a server 103, and a network 104. Wherein the plurality of terminal devices includes terminal device 101 and terminal device 102. Any one of the terminal devices (for example, the terminal device 101 or the terminal device 102) communicates and data transfers with the server 103 via the network 104. The network 104 may be a wired network or a wireless network. The wired network or the wireless network uses standard communication techniques and/or protocols. The network is typically the internet, but can be any network including, but not limited to, a local area network (local area network, LAN), metropolitan area network (metropolitan area network, MAN), wide area network (wide area network, WAN), mobile, wired or wireless network, private network, or any combination of virtual private networks.

A user may interact with server 103 via network 104 using a terminal device (e.g., terminal device 101 or terminal device 102) to receive or send messages, etc. The terminal device may have various low codes installed thereon, such as, but not limited to, any of the following: shopping class applications, web browser applications, search class applications, instant messaging tools, mailbox clients, social platform software, and the like. The terminal device may be various devices having a display screen and supporting web browsing, and the type of the terminal device is not particularly limited. For example, the terminal device may be, but is not limited to being, any one of the following: smart phones, tablet computers, personal computers, or desktop computers, etc.

The server 103 may be a server providing various services. Specifically, the server 103 is configured to provide a background service for an application installed in the terminal device. For example, the server 103 is a background management server for supporting websites browsed by a user using a terminal device, a low-code development platform for supporting development of low-code applications, or an application parsing system for providing multiplexing of low-code applications. The background management server may analyze and process the received data such as the user request, and feed back the processing result (e.g., the web page, information, or data obtained or generated according to the user request) to the terminal device. The server 103 may be a server, a server cluster formed by a plurality of servers, or a cloud computing service center.

It should be noted that, the data processing method of the low-code development platform provided in the present application may be executed by the server 103. By way of example, FIG. 2 illustrates a low code development platform 200 provided by server 103. Referring to FIG. 2, low code development platform 200 may include a catalog bar 201 and a front end design interface. The catalog bar 201 may be used to display components of an entity, and the front-end design interface may be used to display a relationship diagram between the entity, attributes that the entity includes, and logic that the entity includes. Optionally, the low code development platform 200 shown in fig. 2 may further include other controls, which may be set according to actual requirements.

It should be understood that the application scenario shown in fig. 1 is not limited to any application scenario suitable for the data processing method of the low-code development platform provided in the present application. For example, the application scenario illustrated in fig. 1 above may also include a greater number of terminal devices or servers, or a fewer number of terminal devices (e.g., 1 terminal device).

In low-code development platforms, data is generally organized and functionally built on an entity (also called a class or a data object) basis. An entity will typically include multiple attributes and multiple logic. Wherein a reference relationship may exist between logic and attributes comprised by one entity, and a reference relationship may also exist between two different logics comprised by one entity. It is important for a user using the low-code development platform to easily and conveniently obtain the relationship between the attribute and the logic included in one entity and configure the attribute and the logic included in the one entity, so that development efficiency of the user is improved.

In the conventional art, a low-code development platform represents attributes and logic included in one entity through a tree diagram, and configures related information of the attributes and logic included in the one entity through a form. Next, a low code development platform provided by the conventional technology is described with reference to fig. 3. See the low code development platform shown in (1) of fig. 3, which includes a target list. The primary catalog of the target list comprises at least one component of the entity 1, and the secondary catalog of the target list comprises components of a plurality of attributes and components of a plurality of logics, wherein the components of the attributes are included in the entity 1. After performing a selection operation on the components of the entity 1 shown in (1) of fig. 3, the component of the plurality of attributes and the component of the plurality of logics included in the entity 1 may be shown in (1) of fig. 3. Further, after the selection operation is performed on any one attribute component or any one logic component included in the entity 1, configuration information of the any one attribute component or any one logic component is displayed in a form in the low-code development platform shown in (1) in fig. 3. Illustratively, (2) in fig. 3 shows a form interface configured for the attributes or logic included by entity 1 in (1) in fig. 3. Referring to the form shown in (2) of fig. 3, the form includes relevant information of configuration attributes or logic, including: field name, field identification, field description, data type, default values, etc. However, the low code development platform provided by the conventional technology has the following problems: the problems of poor readability, poor operability and poor interactivity are presented to one entity, the attribute included in the one entity and the presentation mode of the logic included in the one entity. Specifically, the scope of information displayed in a tree structure and a list structure in a low-code development platform is limited; through the tree diagram structure, the personalized information of each component included in the target list, such as built-in logic, default logic, read-only attribute and other personalized information, is difficult to embody; through the configuration mode of the form, only one attribute included in the entity or one logic detailed information included in the entity can be checked at the same time; each component displayed in a tree diagram structure in the low-code development platform can only complete interaction in a right-key menu, and configuration of relevant information of attributes or logics can only complete interaction in a form popup window; the low code development platform cannot visually describe the reference relationship between the attributes that one entity includes and the logic that the one entity includes, and the reference relationship between the different logic that the one entity includes.

In order to solve the problems, the application provides a data processing method, a data processing device and electronic equipment of a low-code development platform.

Next, a data processing method of the low code development platform provided in the present application is described with reference to fig. 4 to 10.

Fig. 4 is a schematic diagram of a data processing method of a low-code development platform according to an embodiment of the present application. The data processing method of the low-code development platform described in fig. 4 may be applied to the application scenario shown in fig. 1, but is not limited to the above. In the case where the method described in fig. 4 is applied to the application scenario shown in fig. 1 described above, the server 103 shown in fig. 1 may perform the data processing method of the low-code development platform shown in fig. 4. As shown in fig. 4, the data processing method of the low code development platform provided in the embodiment of the present application includes S410 to S430. Next, S410 to S430 will be described in detail.

First, a platform to which the data processing method of the low-code development platform provided in the embodiment of the present application is applicable will be described.

The data processing method of the low-code development platform provided by the embodiment of the application can be applied to the low-code development platform, wherein the low-code development platform is associated with at least one entity, the entity comprises a first attribute and first logic, and the first attribute and the first logic have a first reference relationship. Alternatively, in other implementations, the entity may include a greater number of attributes and a greater number of logic. For example, the entity may include a first attribute, a first logic and a second logic, where the first logic and the first attribute have a first reference relationship, and the second logic and the first logic have a second reference relationship. Optionally, in other implementations, the low-code development platform may further include other entity associations besides the entity. The type of the low-code platform is not particularly limited, and can be selected according to actual requirements.

S410, acquiring information of an entity, wherein the information comprises: the entity corresponds to a first domain-specific language, a second domain-specific language corresponding to a first attribute, and a third domain-specific language corresponding to a first logic.

The first domain-specific language is a domain-specific language to which the entity corresponds, that is, the first domain-specific language includes information for describing the entity. The second domain-specific language is a domain-specific language corresponding to the first attribute, that is, the second domain-specific language includes information for describing the first attribute. The third domain-specific language is a domain-specific language to which the first logic corresponds, that is, the third domain-specific language includes information for describing the first logic. The type of any one of the first domain-specific language, the second domain-specific language, and the third domain-specific language is not particularly limited, and may be selected according to actual requirements. For example, any of the domain-specific languages described above may be, but are not limited to, HTML language.

Next, information included in the first domain-specific language corresponding to the entity, the second domain-specific language corresponding to the first attribute, and the third domain-specific language corresponding to the first logic is described respectively.

The first domain-specific language corresponding to the entity may include the following information: the method comprises the steps of ID information of an entity, names of a first domain specific language corresponding to the entity, version information of a low-code development platform, type information of the entity, description information of the entity, names of all attributes included by the entity and names of all logics included by the entity. The description information of the entity can be represented by the value of the description field, and is a character string. The names of all the attributes that an entity includes can be represented by an attribute array, which can be expressed, for example, as: properties (pin) [ { name of first attribute } ]. The names of all the logics that an entity includes may be represented by a logic array, which may be represented, for example, as: logics (pin) [ { name of first logic } ]. The second domain-specific language to which the first attribute corresponds may include the following information: the ID information of the first attribute, the name of the first attribute, the description information of the first attribute, default value information of the first attribute, whether the first attribute is persisted, whether the first attribute i is a primary key, and type information of the first attribute. The description information of the first attribute may be represented by a value of a description field, which is a string. The default value information of the first attribute may be represented by a default value of the default value field, where the default value information of the first attribute indicates that the first attribute may be assigned, and before one first attribute is assigned, the value of the first attribute is a default value. Whether the first attribute is persisted or not indicates whether the first attribute is to persist the present first attribute information or not, and whether it is persisted or not may be indicated by the value of the isPersitent field. Whether the first attribute is a primary key indicates whether the first attribute can act as a primary key in the database. The type information of the first attribute may be represented by a value of the schema field, and the type corresponding to the type information of the first attribute may be, but not limited to, the following types: boolean, string, plastic, or floating point. The third domain-specific language to which the first logic corresponds may include the following information: the ID information of the first logic, the name of the first logic, the description information of the first logic, the type information of the first logic, the input parameter information included in the first logic, the initial parameter information, and the local variable information. The description information of the first logic may be represented by a value of the description field, which is a string. The type information of the first logic is represented by a value of a type field, and the types of the first logic include: user-defined logic and default logic (also known as system built-in logic). The input parameter information included in the first logic may be represented by a value of a params field, the output parameter information included in the first logic may be represented by a value of a return field, and the local variable information included in the first logic may be represented by a value of a variables field.

Optionally, in some implementations, any one of the plurality of nodes is in a collapsed state or an expanded state; the entity node in the folded state displays part of the content included in the specific language of the first domain; or, the entity node in the unfolded state displays all the contents included in the first domain-specific language; the first attribute node in the folded state displays part of content included in the second domain-specific language; or, the first attribute node in the unfolded state displays all the contents included in the second domain-specific language; the first logic node in the folded state displays part of content included in the third domain-specific language; alternatively, the first logical node in the expanded state displays all content included in the third domain-specific language. In the implementation manner, any node in the canvas displays the corresponding domain-specific language, so that the user can edit the domain-specific language corresponding to the node. The content of the part included in the corresponding domain-specific language displayed by one node is not particularly limited, and may be set according to actual requirements. Illustratively, (1) in fig. 9 shows what is displayed with the logical 1 node in the expanded state, and (2) in fig. 9 shows what is displayed with the logical 1 node in the collapsed state.

It should be further noted that, in the embodiment of the present application, each node in the canvas only stores the corresponding identifier, and the content displayed by each node is obtained by rendering the domain-specific language acquired from the storage location corresponding to the identifier corresponding to each node. For example, taking an entity node as an example, content displayed by the entity node is obtained by rendering a first domain-specific language acquired from a first storage location corresponding to the entity identifier.

Optionally, in some implementations, obtaining information of the entity includes: acquiring a first domain specific language from a first storage position in a storage space accessed by a low-code development platform according to an entity identifier corresponding to an entity, wherein the entity identifier indicates the first storage position; acquiring a second domain-specific language from a second storage position in the storage space according to a first attribute identifier corresponding to the first attribute, wherein the first attribute identifier indicates the second storage position; and acquiring a third domain-specific language from a third storage position in the storage space according to a first logic identifier corresponding to the first logic, wherein the first logic identifier indicates the third storage position. The storage space accessed by the low-code development platform may be a memory space included in a device running the low-code development platform. In the implementation manner, the domain-specific language is acquired from the storage space accessed by the low-code development platform according to the identifier, so that the aim of data synchronization is fulfilled under the condition that the domain-specific language stored in the storage space accessed by the low-code development platform is updated.

Optionally, in some implementations, the canvas is located in a first area of the low code development platform, the second area of the low code development platform displays a component list, a first-level catalog of the component list displays entity components corresponding to the entities, and a second-level catalog of the component list displays first attribute components corresponding to the first attributes and first logic components corresponding to the first logic; the sub-components of the entity component comprise a first attribute component and a first logic component; before obtaining the information of the entity, the method further comprises: creating a canvas in the first region in response to a selection operation for the entity component; according to the entity components, the following identifications associated with the entity components are obtained: entity identification, first attribute identification and first logic identification. In the implementation manner, by executing the selection operation on the entity component, the canvas for creating the entity association in the first area of the low code platform can be triggered, and the identifier of the entity association is acquired. It can be appreciated that the entity components included in the second region display component list of the low code development platform are determined by acquiring the first domain-specific language according to the first storage location in the storage space accessed by the low code development platform; the first attribute component included in the component list is determined by acquiring a second domain-specific language according to a second storage position in the storage space; the first logical component included in the component list is determined by retrieving a third domain-specific language from a third storage location in the storage space.

S420, rendering in a canvas displayed by the low-code development platform according to the information to generate a plurality of nodes, wherein the plurality of nodes comprise: the entity node corresponding to the entity, the first attribute node corresponding to the first attribute and the first logic node corresponding to the first logic.

In the embodiment of the application, an entity node stores an entity identifier indicating a first storage location, wherein the first storage location stores a first domain-specific language; the first attribute node stores a first attribute identification indicating a second storage location, wherein the second storage location stores a second domain-specific language, the second domain-specific language including a first reference relationship; the first logical node storing a first logical identification indicating a third storage location, wherein the third storage location stores a third domain-specific language, the third domain-specific language including a first reference relationship; the storage space accessed by the low code platform comprises a first storage position, a second storage position and a third storage position. The storage space accessed by the low-code development platform may be a memory space included in a device running the low-code development platform. In the implementation manner, each node in the canvas only stores the corresponding identifier, and the corresponding domain-specific language can be obtained from the storage space accessed by the low-code development platform according to the identifier stored by each node. In this implementation manner, in the case that the first domain-specific language stored in the storage space accessed by the low-code development platform is updated, the updated first domain-specific language can be successfully acquired according to the entity identifier stored in the entity node, that is, the method is convenient for implementing automatic synchronous updating.

In the embodiment of the present application, the states of the plurality of nodes in the canvas are not particularly limited. In some implementations, any one of the plurality of nodes is in a collapsed state or an expanded state; the entity node in the folded state displays part of the content included in the specific language of the first domain; or, the entity node in the unfolded state displays all the contents included in the first domain-specific language; the first attribute node in the folded state displays part of content included in the second domain-specific language; or, the first attribute node in the unfolded state displays all the contents included in the second domain-specific language; the first logic node in the folded state displays part of content included in the third domain-specific language; alternatively, the first logical node in the expanded state displays all content included in the third domain-specific language. In the implementation manner, any node in the canvas displays the corresponding domain-specific language, so that the user can edit the domain-specific language corresponding to the node. In addition, any node is foldable, has the characteristic of hiding, and can improve the space utilization rate of canvas. The content of the part included in the corresponding domain-specific language displayed by any one node is not particularly limited, and may be set according to actual requirements. For example, the entity node displaying the portion of the content included in the first domain-specific language may include at least: name of entity node. Illustratively, (1) in fig. 9 shows what is displayed with the logical 1 node in the expanded state, and (2) in fig. 9 shows what is displayed with the logical 1 node in the collapsed state.

Any one node in the canvas has the following functions: copy, paste, delete, insert, drag, and arrange positions. That is, any one of the node of entity 1, the node of attribute i, and the node of logical j created in the canvas has any one of the functions described above. The method provided by the embodiment of the application describes the entity, the attribute of the entity or the logic of the entity through the nodes in the canvas, and the nodes in the canvas have the functions of copying, pasting, deleting, inserting, dragging, arranging positions and the like. Compared with the traditional technology, the method provided by the embodiment of the application is high in operability, and a more convenient interaction mode is brought to the user. The canvas supports pan and zoom features. When the entity includes more attributes and logic and pays attention to the whole entity, the scaling factor can be reduced, and more node information can be browsed in the canvas at the same time. When information is to be configured or more focused on a particular logic or attribute, the magnification may be translated and enlarged, focusing on a single node. The canvas is not specific. For example, the canvas may be SVG-based.

The embodiment of the application provides two modes to achieve the purpose of rendering and generating a plurality of nodes in canvas displayed by a low code development platform according to information. In the following, both implementations are described.

The implementation mode is as follows:

in a first implementation, rendering a canvas displayed on a low code development platform according to information to generate a plurality of nodes includes: rendering in the canvas according to the initial position information and the information to generate a plurality of nodes, wherein the initial position information is used for indicating that the plurality of nodes are positioned at least one position in the canvas; according to the layout algorithm, the positions of the plurality of nodes at least one position are adjusted, so that the position of any one of the plurality of nodes in the canvas is set according to the position specified by the layout algorithm. In a first implementation manner, at least one initial position in the canvas is set for a plurality of nodes, and then the positions of the plurality of nodes in the canvas are adjusted by using a layout algorithm, so that the position of any one of the plurality of nodes in the canvas is set according to the position specified by the layout algorithm.

In the embodiment of the present application, the layout algorithm is not specifically limited, and may be set according to actual requirements. Optionally, in some implementations, adjusting the positions of the plurality of nodes in the at least one position according to a layout algorithm such that the position of any one of the plurality of nodes in the canvas is set according to the position specified by the layout algorithm includes: according to the layout algorithm, the following operations are performed: adjusting the position of the entity node at least one position so that the entity node is positioned in the middle area of the canvas; adjusting the position of the first logic node at least one position so that the first logic node is positioned in the left area of the entity node; adjusting the position of the first attribute node at least one position so that the first attribute node is positioned in the right area of the entity node; if the first logic corresponding to the first logic node is a first type of logic, the first logic node is specifically located in an upper half area of the left area of the entity node; or if the first logic corresponding to the first logic node is the first type of logic, the first logic node is specifically located in the lower half area of the left area of the entity node. The first type of logic and the second type of logic are not particularly limited, and may be set according to actual requirements. In some implementations, the first type of logic may be default logic and the second type of logic may be user-defined logic.

Optionally, in some implementations, before adjusting the positions of the plurality of nodes at the at least one position according to the layout algorithm, the method further includes: generating a third connecting line between the entity node and the first attribute node in the canvas, wherein the third connecting line is a connecting line of a second type, and the third connecting line represents that the first attribute corresponding to the first attribute node is an attribute included by an entity corresponding to the entity node; and generating a fourth connecting line between the entity node and the first logic node in the canvas, wherein the fourth connecting line is a connecting line of the second type, and the fourth connecting line represents that the first logic corresponding to the first logic node is logic included by the entity corresponding to the entity node. In the above implementation, the canvas may further include a connection between the entity node, the attribute node, and the logical node. It should be noted that, the first type of connection line and the second type of connection line in the present application are two different types of connection lines, and the specific presentation forms of the first type of connection line and the second type of connection line are not limited. For example, the first type of connection line may be a solid line connection line and the second type of connection line may be a dashed line connection line. As another example, the first type of connection line may be a curvilinear connection line and the second type of connection line may be a solid line connection line. For example, referring to the schematic diagram of the low-code development platform shown in (1) in fig. 5, the connection lines of the logical nodes and the entity nodes corresponding to the logic included in the entity are represented by black solid lines in the canvas of the first area included in the low-code development platform, and the connection lines of the attribute nodes and the entity nodes corresponding to the attribute included in the entity are represented by black solid lines. It will be appreciated that the content displayed by each node in the canvas shown in FIG. 5 (1) is not shown.

The implementation mode II is as follows:

in a second implementation manner, rendering in a canvas displayed by a low code platform according to information generates a plurality of nodes, including: rendering in the canvas according to preset position information and information to generate a plurality of nodes, wherein the preset position information indicates that the plurality of nodes are located at a plurality of different positions in the canvas, and the plurality of nodes correspond to the plurality of different positions one by one. In such an implementation, the plurality of nodes may be determined to be located at a plurality of different positions in the canvas directly from the preset position information.

S430, generating a first type of connecting line in the canvas in response to a selection operation for the first attribute node or the first logic node, wherein the first type of connecting line comprises: a first connection line for representing a first reference relationship.

In an embodiment of the present application, generating a first type of connection line in a canvas in response to a selection operation for a first attribute node or a first logical node, includes: responding to a selection operation for the first logic node, and obtaining a first reference relation according to a preset field included in the specific language of the third field, wherein the first reference relation is stored in the preset field; a first connection line is generated in the canvas according to the first reference relationship. In the above implementation manner, the operation of generating the first connection line may be triggered by performing the selection operation on the first logical node. Optionally, in other implementations, in response to a selection operation for the first attribute node or the first logical node, generating a first type of connection line in the canvas, wherein the first type of connection line comprises: a first connection line for representing a first reference relationship, comprising: responding to a selection operation aiming at the first attribute node, and obtaining a first reference relation according to a preset field included in a third domain specific language, wherein the first reference relation is stored in the preset field; a first connection line is generated in the canvas according to the first reference relationship. In this implementation, the operation of generating the first connection line may be triggered by performing a selection operation on the first attribute node.

Optionally, in some implementations, the first reference relationship is a reference relationship in which the first logic references the first attribute, where the first connection line specifically represents a connection line that points from the first logical node to the first attribute node, or the first connection line specifically represents a connection line that points from the first attribute node to the first logical node. Illustratively, referring to the schematic diagram of the low code development platform shown in (1) of FIG. 5, the low code development platform includes a canvas of a first region in which a first attribute node points to a first logical node as depicted in black dashed lines.

Optionally, in some implementations, the canvas is located in a first area of the low code development platform, the second area of the low code development platform displays a component list, the component list includes a first-level catalog that displays entity components corresponding to the entities, and the second-level catalog that includes the component list displays first attribute components corresponding to the first attributes and first logic components corresponding to the first logic; the sub-components of the entity component comprise a first attribute component and a first logic component; the method further comprises the steps of: in the event that an update occurs to a domain-specific language corresponding to any one of a plurality of nodes in the canvas, performing the following operations: rendering any node in the canvas according to the updated domain-specific language corresponding to any node; and updating the components associated with any node, wherein if any node is an entity node, the components associated with any node are entity components; if any node is the first attribute node, the component associated with any node is the first attribute component; or if any node is the first logical node, the component associated with any node is the first logical component. The second area and the first area may be two different areas, and the positions of the first area and the second area in the low-code development platform are not specifically limited, and may be set according to actual requirements. For example, referring to the schematic diagram of the low code development platform shown in (2) of fig. 5, the low code development platform includes a first region on the right side and a second region on the left side. The second area displays a target list, a first-level catalog of the target list comprises an entity component of an entity, and a second-level catalog of the target list comprises: a first attribute component of the first attribute and a first logic component of the first logic. In the implementation manner, under the condition that the domain-specific language corresponding to any node in the plurality of nodes in the canvas is updated, the updating of the corresponding component in the component list of the low-code platform and the updating of the corresponding node in the canvas can be realized.

Optionally, in other implementations, after generating the first type of connection line in the canvas in response to the selection operation for the first attribute node or the first logical node, the method further comprises: responding to the satisfaction of preset conditions, and adjusting the positions of nodes in the canvas according to a layout algorithm, so that the nodes in the canvas are set according to the positions specified by the layout algorithm; wherein satisfying the preset condition includes at least one of: deleting any node in the plurality of nodes, changing the size of any node, and generating a new node in the canvas; the size of any node is associated with the content displayed by any node, and the new node is a node corresponding to a new attribute included in the entity or a node corresponding to a new logic included in the entity. The preset conditions are not particularly limited, and may be set according to actual requirements. In the above implementation manner, after the first type of connection line is generated, the execution of the layout algorithm may be triggered again if the preset condition is satisfied.

Next, a description will be given of a change in the size of any node in the canvas. In the present embodiment, the following two cases have an impact on the size of the nodes that have been created in the canvas. These two cases will be described separately.

Case one:

one node in the canvas has a collapsed state and an expanded state, the one node changes from the collapsed state to the expanded state, or the one node changes from the expanded state to the collapsed state, the one node changing in size. Specifically, one node changes from an unfolded state to a folded state, and the one node becomes smaller; one node changes from a collapsed state to an expanded state, and the one node becomes larger.

Taking a logical node as an example, the logical node in the folded state only displays basic information such as a logical name, a default value, an input parameter, an output parameter and the like. The logical nodes in the expanded state can display detailed information and can perform editing operations. For example, fig. 9 (1) shows a schematic diagram of a node which is a logical 1 in an expanded state; fig. 9 (2) shows a schematic diagram of a node which is a logical 1 in a folded state.

And a second case:

the size of a node in the canvas is stretched by the internal elements that the node includes, that is, an increase or decrease in the internal element information of the node affects the size change of the node. For example, the node (1) in fig. 9 is a node of logical 1 in an expanded state, and when the internal element of the node does not include information whether or not it is a static method, the height of the node of logical 1 will become small. For example, the node (1) in fig. 9 is a node of logical 1 in an expanded state, and when the internal element of the node further includes a plurality of input parameters and a plurality of output parameters, the height of the node of logical 1 will become larger.

Optionally, in other implementations, the entity further includes second logic, where the second logic and the first logic have a second reference relationship, and the information further includes: a fourth domain-specific language corresponding to the second logic; the plurality of nodes further includes: a second logical node corresponding to the second logic; the first type of connection line further comprises: a second connection line for representing a second reference relationship. In the above implementations, the canvas may also visually describe the referencing relationships between the different logic that the entity includes.

It should be understood that the data processing method of the low-code development platform described in fig. 4 is merely illustrative, and does not constitute any limitation on the data processing method of the low-code development platform provided in the present application. For example, the low-code development platform described above may also include other controls. For example, the entity may also include a greater number of attributes and a greater number of logics, where the canvas may include a greater number of nodes and a greater number of links. For example, the layout algorithm described above in fig. 4 may be replaced with any one of the following algorithms: a ring layout, or a mesh layout.

In the embodiment of the application, corresponding nodes are respectively created for an entity, a first attribute and a first logic included in the entity in a canvas included in a low-code development platform, and a first connection line between the first logic node and the first attribute node is generated in the canvas, wherein the first connection line represents a first reference relation between the first logic and the first attribute. In the case where the entity further includes a second logic, a node corresponding to the second logic is also created in the canvas, and a second connection line between the second logic and the first logic is generated at the canvas, the second connection line representing a second reference relationship between the first logic and the second logic. That is, the method may visually describe the relationship between the attributes and logic that an entity includes, as well as the relationship between the different logic that an entity includes. The method provided by the embodiment of the application describes the entity, the attribute of the entity or the logic of the entity through the nodes in the canvas, and the nodes in the canvas have the functions of copying, pasting, deleting, inserting, dragging, arranging positions and the like. Compared with the traditional technology, the method provided by the embodiment of the application is high in operability, and a more convenient interaction mode is brought to the user. The canvas supports pan and zoom features. In addition, the nodes in the canvas can display the corresponding domain-specific language, so that the readability is high. In the scheme provided by the application, under the condition that the data source of the entity (namely, the information related to the entity stored in the storage space accessed by the low-code development platform) is updated, the components corresponding to the entity included in the catalog list displayed by the low-code development platform and the nodes included in the canvas displayed by the low-code development platform are automatically updated, so that data synchronization can be realized.

Next, a data processing method of another low-code development platform provided in an embodiment of the present application is described with reference to fig. 6. It will be appreciated that the data processing method of the low-code development platform described in fig. 6 is a specific example of the data processing method of the low-code development platform described in fig. 4.

Fig. 6 is a schematic diagram of a data processing method of another low-code development platform according to an embodiment of the present application. It should be understood that the example of fig. 6 is merely to aid one skilled in the art in understanding the present embodiments, and is not intended to limit the present embodiments to the specific values or particular scenarios illustrated. Various equivalent modifications and variations will be apparent to those skilled in the art from the example of fig. 6 given below, and such modifications and variations are intended to be within the scope of the embodiments of the present application. By way of example, the execution subject of the data processing method of the low-code development platform is described below in fig. 6 as an example of the server 1. As shown in fig. 6, the data processing method of the low code development platform includes S610 to S640. Next, S610 to S640 are described in detail.

S610, displaying a low-code development platform 1 on the server 1, wherein the area 1 displayed by the low-code development platform 1 is used for displaying a target list; the primary catalog of the target list is used for displaying the components of entity 1; the secondary directory of the target list is used to display the components of attribute i and the components of logic j comprised by entity 1, i=1, 2,3, j=1, 2.

In the embodiment of the present application, the entity 1 specifically includes 3 attributes (i.e., attribute i) and 2 logics (i.e., attribute j). A reference relationship may exist between different logic comprised by an entity and a reference relationship may also exist between logic and attributes comprised by an entity. Specifically, in the embodiment of the present application, a logic 1 references a logic 2, and a logic 1 references an attribute 2; logical 2 refers to attribute 1 and logical 2 refers to attribute 3. In S610, the primary directory of the target list is used to display the components of entity 1; the secondary catalog of the target list is used to display the components of attribute i and the components of logic j that entity 1 includes. It will be appreciated that, after the selection operation is performed on the components of entity 1 in the primary catalog of the target list, the target list will display the secondary catalog. For example, the low code development platform 1 shown in (1) of fig. 8 includes a target list displayed in the region 1, wherein a primary directory of the target list includes components of the entity 1. For example, the low code development platform 1 shown in (2) of fig. 8 includes a target list displayed in the region 1, wherein a primary directory of the target list includes: a component of entity 1; the secondary catalog of the target list includes: a component of attribute 1, a component of attribute 2, a component of attribute 3, a component of logic 1, a component of logic 2. It will be appreciated that the directory list displayed in the area 1 may display a plurality of components included in the secondary directory shown in (2) of fig. 8 by performing a selection operation (e.g., a click operation) on the components of the entity 1 shown in (1) of fig. 8.

In the embodiment of the present application, the target list displayed by the low-code development platform 1 includes components associated with the entity 1, which are determined according to the information of the entity 1 stored in the memory space of the server 1. That is, the components of entity 1 in the primary catalog of the target list displayed by the low code development platform 1, and the components of attribute i and the components of logic j in the secondary target of the target list are determined based on the information of entity 1 stored in the memory space of the server 1. In other words, in the case that the information of the entity 1 stored in the memory space of the server 1 is changed, the components in the target list displayed by the low-code development platform 1 are updated accordingly.

Next, information of the entity 1 stored in the memory space of the server 1 will be described in detail. The information of the entity 1 stored in the memory space of the server 1 includes: DSL information for entity 1, DSL information for attribute i, and DSL information for logic j. The DSL information of entity 1 may include the following information: the ID information of entity 1, the name of entity 1, version information of the low-code development platform, type information of entity 1, description information of entity 1, names of all attributes included in entity 1, and names of all logics included in entity 1. The ID information of the entity 1 may be represented by a value of an ID field, and the value of the ID field of the entity 1 may be represented as: agent-random string 1. For example, the id field of entity 1 may be valued as: agent-3181748950113732111. The name of entity 1 may be represented by the value of the name field. Version information of the low code development platform may be represented by the value of the ideVersion field. The type information of the entity 1 may be represented by a value of a type field, which is an actor string. The description information of the entity 1 can be represented by the value of the description field, and is a character string. The names of all the attributes included in the entity 1 may be represented by an attribute array, which may be represented as: properties (pin) [ { name of attribute 1 }, { name of attribute 2 }, { name of attribute 3 } ]. The names of all the logics included in entity 1 may be represented by a logic array, which may be represented, for example, as: logics (pin) [ { name of logic 1 }, { name of logic 2 } ]. It should be noted that, in the embodiment of the present application, one piece of information is represented by a value of one field, that is, the value of the one field represents the one piece of information. For example, the ID information of the entity 1 may be represented by the value of the ID field, and then the value of the ID field of the entity 1 represents the ID information of the entity 1. The DSL information of attribute i may include the following information: the ID information of the attribute i, the name of the attribute i, the description information of the attribute i, default value information of the attribute i, whether the attribute i is persisted, whether the attribute i is a primary key, and type information of the attribute i. The ID information of the attribute i may be represented by a value of the ID field. The name of attribute i may be represented by the value of the name field. The description information of the attribute i can be represented by the value of the description field, and is a character string. The default value information of the attribute i can be represented by the default value of the default value field, the default value information of the attribute i indicates that the attribute i can be assigned, and the value of the attribute i is the default value before the attribute i is assigned. Whether attribute i is persisted or not indicates whether attribute i is to persist the present attribute information or not, and whether it is persisted or not may be indicated by the value of the isPersitent field. Whether attribute i is a primary key indicates whether attribute i can act as a primary key in the database. The type information of the attribute i can be represented by the value of the schema field, and the type corresponding to the type information of the attribute i can be, but is not limited to, the following types: boolean, string, plastic, or floating point. The DSL information of logic j may include the following information: ID information of the logic j, name of the logic j, description information of the logic j, type information of the logic j, input parameter information included in the logic j, initial parameter information, and local variable information. The ID information of the logic j may be represented by the value of the ID field. The name of logical j may be represented by the value of the name field. The description information of the logic j can be represented by the value of the description field, and is a character string. The type information of the logic j is represented by the value of the type field, and the types of the logic j include: user-defined logic and default logic (also known as system built-in logic). The input parameter information included in the logic j can be represented by the value of the params field, the output parameter information included in the logic j can be represented by the value of the return field, and the local variable information included in the logic j can be represented by the value of the variables field.

S620, in response to a selection operation of the component of the entity 1, creating a node of the entity 1, a node of the attribute i, and a node of the logic j in the canvas of the region 2 displayed by the low code development platform 1.

In an embodiment of the present application, the canvas of region 2 displayed by the low code development platform 1 may be SVG-based. Wherein, any node in the canvas has the following functions: copy, paste, delete, insert, drag, and arrange positions. That is, any one of the node of entity 1, the node of attribute i, and the node of logical j created in the canvas has any one of the functions described above. The method provided by the embodiment of the application describes the entity, the attribute of the entity or the logic of the entity through the nodes in the canvas, and the nodes in the canvas have the functions of copying, pasting, deleting, inserting, dragging, arranging positions and the like. Compared with the traditional technology, the method provided by the embodiment of the application is high in operability, and a more convenient interaction mode is brought to the user.

In the embodiment of the present application, performing S620 described above includes S621 and S622. By way of example, fig. 7 shows S621 and S622. Next, S621 and S622 will be described in detail.

S621, in response to a selection operation of a component of the entity 1, a canvas is created in the region 2 displayed by the low code development platform 1.

The above S621 is performed, that is, by selecting an element of the entity 1 displayed on the low-code development platform 1, the canvas corresponding to the entity 1 may be triggered to be created, and the created canvas is displayed in the area 2 displayed on the low-code development platform 1. After executing S621 described above, a canvas corresponding to entity 1 may be created in region 2 displayed by the low code development platform 1. It is understood that the canvas obtained after the above S621 is performed is an empty canvas.

Region 2 and region 1 are two distinct regions that the low code development platform 1 includes, and there is no overlapping region for region 2 and region 1. The positions of the region 1 and the region 2 in the low-code development platform 1 are not particularly limited. In the embodiment of the present application, the region 1 may be located in a left region of the low code development platform 1, and the region 2 may be located in a right region of the low code development platform 1. Illustratively, the region 2 for displaying canvas shown in (3) of fig. 8 is located at the right side region of the low code development platform 1, and the region 1 for displaying directory list is located at the left side region of the low code development platform 1.

S622, in response to creating the canvas in the area 2 displayed by the low code development platform 1, generating a node of the entity 1 in a folded state at an initial position 1 of the canvas according to DSL information of the entity 1, generating a node of the attribute i in a folded state at the initial position 1 of the canvas according to DSL information of the attribute i, and generating a node of the logic j in a folded state at the initial position 1 of the canvas according to DSL information of the logic j.

In the present embodiment, initial position 1 is used to represent a specific position in the canvas. Where the initial position 1 may be represented by two-dimensional coordinates (x, y), x representing the abscissa located on the canvas and y representing the ordinate located on the canvas. The initial position 1 may be a preset position, and the initial position 1 is not specifically limited and may be set according to actual requirements. For example, the initial position 1 may be, but is not limited to, (0, 0). It will be appreciated that after executing S622 above, the node of entity 1, the node of attribute i, and the node of logic j in the canvas are all located at initial position 1, i.e., the plurality of nodes overlap at initial position 1; and the state of any one node is a folded state. By way of example, (4) in fig. 8 shows a schematic view of the initial position 1.

In the embodiment of the present application, the node (e.g., collapsed or expanded state) of entity 1 in the canvas is used only to store the id of entity 1, where the id of entity 1 represents the storage location of DSL information of entity 1 in the memory space of server 1. That is, the server 1 may find DSL information of the entity 1 stored in the memory space of the server 1 according to the id of the entity 1, and then render the DSL information of the entity 1 found from the memory space of the server 1 in nodes of the entity 1 in the canvas, so that the DSL information of the entity 1 may be known through the nodes of the entity 1. Based on the same principle, the node of the attribute i in the canvas is used to store the id of the attribute i, where the id of the attribute i is used to represent the storage location of the DSL information of the attribute i in the memory space of the server 1. The node of the logic j in the canvas is used to store the id of the logic j, wherein the id of the logic j is used to represent the storage location of the DSL information of the logic j in the memory space of the server 1. That is, any one node in the canvas described in the embodiment of the present application is used to store the position reference information of the DSL information corresponding to the one node, and not store the DSL information corresponding to the any one node. In the embodiment of the present application, in the case that DSL information stored in the memory space of the server 1 changes, the corresponding node in the canvas may be updated in time. That is, any node in the canvas stores only references to information corresponding to that any node, particularly for ease of maintenance and modification, as well as to ensure the benefits of data synchronization. In addition, the components associated with the entity 1 in the target list displayed by the low code development platform 1 are also determined according to the information of the entity 1 stored in the memory space of the server 1, that is, in the case that DSL information stored in the memory space of the server 1 changes, synchronization of the components associated with the entity 1 in the target list displayed by the area 1 of the low code development platform 1 and the nodes associated with the entity 1 displayed in the canvas of the area 2 of the low code development platform 1 can be achieved.

In the embodiment of the application, the state of any node in the canvas of the area 2 displayed by the low code development platform 1 may be a folded state or an unfolded state. It is understood that the above description is given by taking the state of any node in the canvas as the collapsed state as an example in S622. When any node state in the canvas is a collapsed state, the any node in the collapsed state represents a function corresponding to the one node, and the function corresponding to the one node is: an entity, attribute, or logic. In the case that any one node state in the canvas is the expanded state, the any one node in the expanded state may represent the function corresponding to the one node in detail. One node in the canvas is in a folded state, namely the one node has the characteristic of being hidden, and the improvement of the air inlet utilization rate of the canvas is facilitated.

Next, description will be made of contents included in a collapsed state or an expanded state when one node in the canvas is a node of entity 1, a node of attribute i, or a node of logic j. Wherein, the node of the entity 1 in the collapsed state displayed in the canvas at least comprises the following information: name of entity 1. The nodes of entity 1 in the expanded state displayed in the canvas may include the following information: the ID information of entity 1, the name of entity 1, version information of the low-code development platform, type information of entity 1, description information of entity 1, names of all attributes included in entity 1, and names of all logics included in entity 1. The nodes of the attribute i in the folded state displayed in the canvas at least comprise the following information: names of attributes. Wherein, the node of the attribute i in the unfolded state displayed in the canvas comprises the following information: the ID information of the attribute i, the name of the attribute i, the description information of the attribute i, default value information of the attribute i, whether the attribute i is persisted, whether the attribute i is a primary key, and type information of the attribute i. Taking an attribute node as an example, only the name, default value, persistence, index and other basic information of the attribute are displayed in the folded state. The expanded state can display detailed information and can perform editing operation. The left graph is the state when the node is unfolded, and the right graph is the state when the node is folded. The nodes of the logic j in the folded state displayed in the canvas at least comprise the following information: name of logical j. The nodes of logical j in the expanded state displayed in the canvas may include the following information: ID information of the logic j, name of the logic j, description information of the logic j, type information of the logic j, input parameter information included in the logic j, initial parameter information, and local variable information. Illustratively, (1) in fig. 9 shows a node of logical 1 in an unfolded state, and (2) in fig. 9 shows a node of logical 1 in a folded state.

Optionally, before performing S622 above, the following operations may also be performed: DSL information of the entity 1, DSL information of the attribute i and DSL information of the logic j are obtained from the memory space of the server 1. In such an implementation, the process of obtaining information of entity 1 may be successfully triggered by creating a canvas in region 2 displayed by low code development platform 1.

In the embodiment of the present application, the canvas described in S622 above is associated with entity 1. Wherein the canvas may be implemented based on a diagram engine antv-x 6. Performing S622 above may include the steps of: after creating a canvas in the area 2 displayed by the low code development platform 1, responding to double-clicking the component of the entity 1 in the target list displayed by the low code development platform 1, calling a canvas creation method, and simultaneously transmitting the canvas into the id of the entity 1; acquiring information of the entity 1 from a memory space of the server 1 according to the id of the entity 1, wherein the information of the entity 1 comprises: DSL information for entity 1, DSL information for attribute i, and DSL information for logic j.

S630, adjusting the positions of nodes in the canvas according to a layout algorithm, so that the nodes of the attribute i are uniformly arranged in the right area of the nodes of the entity 1, the nodes of the logic j are arranged in the left area of the nodes of the entity 1, and initial connection is carried out on the nodes corresponding to the entity 1.

After executing S620, the executing S630, that is, after creating a canvas in the region 2 included in the low code development platform 1 and adding all nodes and initial links corresponding to the entity 1 associated with the canvas, automatically triggers the layout algorithm to re-layout the nodes in the canvas.

It should be noted that, in the embodiment of the present application, the layout algorithm may be triggered by any one of the following operations: creating canvas in a region 2 included in the low code development platform 1 and adding all nodes and initial connection wires corresponding to the entities 1 associated with the canvas; adding and/or deleting the node corresponding to the entity 1 associated with the canvas in the canvas; alternatively, the size of the nodes in the canvas changes. Wherein the canvas of entity 1 would monitor the size of any one node in the canvas. After the size of any node is changed, the layout algorithm is automatically triggered to re-layout the nodes in the canvas. That is, in the embodiment of the present application, when a node is newly added to the canvas, a node is deleted, or the size of the node in the canvas changes, a process of executing automatic layout on the node in the canvas according to the layout algorithm is triggered, so as to ensure the accuracy of the layout of the canvas corresponding to the entity 1.

In the embodiment of the present application, the layout algorithm described in S630 above is used to specify: setting a node of an entity at the center of the canvas, wherein the logical node included in the entity corresponding to the node of the entity is arranged in the left area of the node of the entity, and the attribute node included in the entity corresponding to the node of the entity is arranged in the right area of the node of the entity. The logic is divided into default logic and user-defined logic, and the two types of logic are respectively arranged on the upper side and the lower side of the left area of the node of the entity by taking the node of the entity as a boundary. The nodes of the attribute are uniformly distributed in the right area of the nodes of the entity from top to bottom by taking the ordinate of the nodes of the entity as the center. Illustratively, referring to the canvas of the region 2 included in the low code development platform 1 shown in (1) of fig. 10, the logic j included in the entity 1 is a default logic, and the nodes of the logic j are uniformly arranged in the upper left half region of the nodes of the entity 1; the attributes i included in the entity 1 are uniformly arranged in the right area of the node of the entity 1. As shown in FIG. 10 (1), an add-on logic component and an add-on properties component can also be included in the canvas.

The node corresponding to the entity 1 includes: a node of entity 1, a node of attribute i and a node of logic j. The initial connection of the node corresponding to the entity 1 is used for representing: the entity 1 includes attributes and logic. For example, referring to the solid broken line shown in (1) in fig. 10, the solid broken line may be understood as an initial connection line associated with a node corresponding to entity 1, and specifically includes: a connection between the node of entity 1 and the default logic, a connection between the node of entity 1 and the newly added logic component, a connection between the node of entity 1 and the node of attribute 1, and a connection between the node of entity 1 and the newly added attribute component.

In the present embodiment, the following two cases have an impact on the size of the nodes that have been created in the canvas. These two cases will be described separately.

Case one:

And a second case:

S640, in response to performing a selection operation on the node of logic 2 in the canvas, generating a virtual polyline 1 in the canvas, with the node of logic 2 pointing to the node of logic 1, attribute 1 pointing to the virtual polyline 2 of logic 2, and attribute 3 pointing to the virtual polyline 3 of logic 2, according to the ID information included in the DSL information of logic 2.

After the above S640 is performed, the reference relationship between the logic and the attribute included in the entity 1, and the reference relationship between the logic and the logic can be clearly known in the canvas.

Dashed line 1 indicates that logic 2 is referenced by logic 1; dashed line 2 indicates that attribute 1 is referenced by logical 2; dashed line 3 indicates that attribute 3 is referenced by a logical 2.

The DSL information of logic 2 includes ID information for storing: a reference relationship between logical 2 and other logic comprised by entity 1, and a reference relationship between logical 2 and attribute i.

Wherein generating, in the canvas, a dashed line 1 in which the node of logic 2 points to the node of logic 1, an imaginary line 2 in which attribute 1 points to logic 2, and an imaginary line 3 in which attribute 3 points to logic 2, according to the ID information included in the DSL information of logic 2, in response to performing the selecting operation for the node of logic 2 in the canvas, comprises: in response to performing a selection operation for a node of logic 2 in the canvas, generating a reference relationship table of logic 2 from the ID information included in the DSL information of logic 2, wherein the reference relationship table of logic 2 comprises: the id of logical 1 refers to the reference relationship between ids of logical 2, the id of logical 2 refers to the reference relationship between ids of attribute 1, and the id of logical 2 refers to the reference relationship between ids of attribute 3; according to the reference relation table of logic 2, virtual broken line 1, in which the node of logic 2 points to the node of logic 1, virtual broken line 2, in which attribute 1 points to logic 2, and virtual broken line 3, in which attribute 3 points to logic 2, are generated in the canvas. By way of example, table 1 shows the reference relationship table for logical 2 described above, it being understood that table 1 is illustrative only and not limiting in any way.

TABLE 1

Id of referent	The id of the referee
		Id of logic 1	Id of logic 2
Id of logic 2	Id of attribute 1
		Id of logic 2	Id of attribute 3

For example, the content displayed by the canvas after performing S640 described above may be referred to in fig. 10 (2). Referring to (2) in fig. 10, the reference relationship in which logical 1 references logical 2 is represented by a broken line in which logical 2 points to logical 1; logical 2 references the relationship of attribute 1 as represented by the dashed line of attribute 1 pointing to logical 2; logical 2 references the reference relationship of attribute 3 by a dashed line of attribute 3 pointing to logical 2. From what is shown in (2) in fig. 10, the reference relationship between the logic 2 included in the entity 1 and the logic (or attribute) other than the logic 2 included in the entity 1 can be clearly and intuitively known.

In this embodiment of the present application, after adding an entity canvas in the region 2 displayed by the low code development platform 1, the relevant information of the entity 1 included in the target list in the region displayed by the low code development platform 1 is not removed, and editing of the relevant information of the entity may still be performed in the tree diagram and the form, where canvas nodes and data corresponding to one in the tree diagram need to be synchronized. The components corresponding to the entity 1 included in the directory list in the area 1 displayed by the low-code development platform 1 are also determined according to the data stored in the memory space of the server 1, where the components corresponding to the entity 1 include: the components of entity 1, the components of attribute i, and the components of logic j. That is, after the components corresponding to the entity 1 included in the directory list in the area 1 are modified, the information associated with the entity 1 stored in the memory space of the server 1 is correspondingly modified. In the embodiment of the application, any node in the canvas is only used for storing the id of the entity, the id of the attribute or the id of the logic corresponding to the any node. That is, any node in the canvas is not used to directly store the data of the entity, attribute, or logic corresponding to that any node. The data of the entity, attribute or logic corresponding to any node is obtained by querying from the memory space of the server 1 providing the low-code development platform 1 according to the id of the entity, the id of the attribute or the id of the logic corresponding to any node. That is, in the scheme provided by the application, when the data source of the entity 1 (i.e. DSL information associated with the entity 1 stored in the memory space in the server 1) is modified, the components corresponding to the entity 1 included in the directory list in the area 1 displayed by the low-code development platform 1 are automatically updated, and the nodes included in the canvas in the area 2 displayed by the low-code development platform 1 are automatically updated.

It should be understood that the method described in fig. 6 is merely illustrative, and does not constitute any limitation on the data processing method of the low-code development platform provided in the present application. For example, the layout algorithm involved in the method described above in fig. 6 may also be replaced with any one of the following algorithms: a ring layout, or a mesh layout.

In the above, the application scenario and the data processing method of the low-code development platform, to which the data processing method of the low-code development platform provided by the application is applicable, are described in detail with reference to fig. 1 to 10.

Next, a data processing apparatus and an electronic device provided in the present application are described with reference to fig. 11 and 12. It is to be understood that the above data processing method corresponds to the data processing apparatus and the electronic device described below. Details not described in detail below can be found in the relevant description of the method embodiments described above.

Fig. 11 is a schematic structural diagram of a data processing apparatus of a low-code development platform according to an embodiment of the present application. The data processing device of the low-code development platform is applied to the low-code development platform, wherein the low-code development platform is associated with at least one entity, the entity comprises a first attribute and first logic, and a first reference relationship exists between the first attribute and the first logic. As shown in fig. 11, the apparatus includes an acquisition unit 1101 and a processing unit 1102,

The acquisition unit 1101 is configured to: obtaining information of the entity, wherein the information comprises: a first domain-specific language corresponding to the entity, a second domain-specific language corresponding to the first attribute, and a third domain-specific language corresponding to the first logic; the processing unit 1102 is configured to: rendering in a canvas displayed by the low code development platform according to the information to generate a plurality of nodes, wherein the nodes comprise: the entity node corresponding to the entity, the first attribute node corresponding to the first attribute and the first logic node corresponding to the first logic; the processing unit 1102 is further configured to: generating a first type of connection line in the canvas in response to a selection operation for the first attribute node or the first logical node, wherein the first type of connection line comprises: a first connection line for representing the first reference relationship.

Optionally, in some implementations, the entity node stores an entity identification indicating a first storage location, wherein the first storage location stores the first domain-specific language; the first attribute node stores a first attribute identification indicating a second storage location, wherein the second storage location stores the second domain-specific language, the second domain-specific language including the first reference relationship; the first logical node stores a first logical identification indicating a third storage location, wherein the third storage location stores the third domain-specific language, the third domain-specific language including the first reference relationship; wherein the storage space accessed by the low code platform includes the first storage location, the second storage location, and the third storage location.

Optionally, in other implementations, any one of the plurality of nodes is in a collapsed state or an expanded state; the entity node in the folded state displays partial content included in the first domain-specific language; or, the entity node in the unfolded state displays all contents included in the first domain-specific language; the first attribute node in the folded state displays part of the content included in the second domain-specific language; or, the first attribute node in the expanded state displays all contents included in the second domain-specific language; the first logic node in the folded state displays part of the content included in the third domain-specific language; alternatively, the first logical node in the expanded state displays all content included in the third domain-specific language.

Optionally, in other implementations, the obtaining unit 1101 is further configured to: acquiring the first domain-specific language from a first storage position in a storage space accessed by the low-code development platform according to an entity identifier corresponding to the entity, wherein the entity identifier indicates the first storage position; acquiring the second domain-specific language from a second storage position in the storage space according to a first attribute identifier corresponding to the first attribute, wherein the first attribute identifier indicates the second storage position; and acquiring the third domain-specific language from a third storage position in the storage space according to a first logic identifier corresponding to the first logic, wherein the first logic identifier indicates the third storage position.

Optionally, in other implementations, the canvas is located in a first area of the low code development platform, a second area of the low code development platform displays a component list, a primary catalog of the component list displays entity components corresponding to the entity, and a secondary catalog of the component list displays first attribute components corresponding to the first attribute and first logic components corresponding to the first logic; the sub-components of the entity component include the first attribute component and the first logic component; the processing unit 1102 is further configured to, prior to the acquiring the information of the entity: creating the canvas in the first region in response to a selection operation for the entity component; according to the entity component, the following identification associated with the entity component is obtained: the entity identity, the first attribute identity, and the first logical identity.

Optionally, in other implementations, the processing unit 1102 is further configured to: rendering in the canvas according to initial position information and the information to generate the plurality of nodes, wherein the initial position information is used for indicating that the plurality of nodes are positioned at least one position in the canvas; and adjusting the positions of the nodes at the at least one position according to a layout algorithm, so that the positions of any one of the nodes in the canvas are set according to the positions specified by the layout algorithm.

Optionally, in other implementations, the processing unit 1102 is further configured to: according to the layout algorithm, the following operations are executed: adjusting the position of the entity node at the at least one position so that the entity node is located in the middle area of the canvas; adjusting the position of the first logical node at the at least one position so that the first logical node is located in the left area of the entity node; adjusting the position of the first attribute node at the at least one position so that the first attribute node is located in the right area of the entity node; if the first logic corresponding to the first logic node is a first type logic, the first logic node is specifically located in an upper half area of the left area of the entity node; or if the first logic corresponding to the first logic node is the logic of the first type, the first logic node is specifically located in the lower half area of the left area of the entity node.

Optionally, in other implementations, before the adjusting the positions of the plurality of nodes at the at least one position according to the layout algorithm, the processing unit 1102 is further configured to: generating a third connecting line between the entity node and the first attribute node in the canvas, wherein the third connecting line is a connecting line of a second type, and the third connecting line represents that the first attribute corresponding to the first attribute node is an attribute included by an entity corresponding to the entity node; and generating a fourth connecting line between the entity node and the first logic node in the canvas, wherein the fourth connecting line is the connecting line of the second type, and the fourth connecting line represents that the first logic corresponding to the first logic node is logic included by an entity corresponding to the entity node.

Optionally, in other implementations, the processing unit 1102 is further configured to: rendering in the canvas according to preset position information and the information to generate the plurality of nodes, wherein the preset position information indicates that the plurality of nodes are located at a plurality of different positions in the canvas, and the plurality of nodes are in one-to-one correspondence with the plurality of different positions.

Optionally, in other implementations, the processing unit 1102 is further configured to: responding to the selection operation for the first logic node, and obtaining the first reference relation according to a preset field included in the third domain specific language, wherein the first reference relation is stored in the preset field; the first connection line is generated in the canvas according to the first reference relationship.

Optionally, in other implementations, the canvas is located in a first area of the low code development platform, a second area of the low code development platform displays a component list, a primary catalog included in the component list displays entity components corresponding to the entities, and a secondary catalog included in the component list displays first attribute components corresponding to the first attributes and first logic components corresponding to the first logic; the sub-components of the entity component include the first attribute component and the first logic component;

Optionally, in other implementations, the processing unit 1102 is further configured to: in the event that an update occurs to a domain-specific language corresponding to any one of the plurality of nodes in the canvas, performing the following operations: rendering the any node in the canvas according to the updated domain-specific language corresponding to the any node; updating the components associated with any node, wherein if any node is the entity node, the components associated with any node are the entity components; if any node is the first attribute node, the component associated with any node is the first attribute component; or if any node is the first logical node, the component associated with the any node is the first logical component.

Optionally, in other implementations, the processing unit 1102 is further configured to: responding to the satisfaction of preset conditions, and adjusting the positions of nodes in the canvas according to a layout algorithm, so that the nodes in the canvas are set according to the positions specified by the layout algorithm; wherein, the meeting the preset condition includes at least one of the following conditions: deleting any node in the plurality of nodes, changing the size of any node, and generating a new node in the canvas; the size of any node is associated with the content displayed by the any node, and the new node is a node corresponding to a new attribute included by the entity or a node corresponding to a new logic included by the entity.

Optionally, in other implementations, the entity further includes second logic, where the second logic and the first logic have a second reference relationship, and the information further includes: a fourth domain-specific language corresponding to the second logic; the plurality of nodes further includes: a second logical node corresponding to the second logic; the first type of connection line further comprises: and a second connection line for representing the second reference relationship.

Optionally, in other implementations, the first reference relationship is a reference relationship in which the first logic references the first attribute, where the first connection line specifically represents a connection line from the first logical node to the first attribute node, or the first connection line specifically represents a connection line from the first attribute node to the first logical node.

Fig. 12 is a schematic structural diagram of an electronic device according to an embodiment of the present application. As shown in fig. 12, includes a memory 1201, a processor 1202, a communication interface 1203, and a communication bus 1204. The memory 1201, the processor 1202 and the communication interface 1203 are connected to each other by a communication bus 1204.

The memory 1201 may be a Read Only Memory (ROM), a static storage device, a dynamic storage device, or a random access memory (random access memory, RAM). The memory 1201 may store a program, and when the program stored in the memory 1201 is executed by the processor 1202, the processor 1202 and the communication interface 1203 are configured to execute respective steps of a data processing method of the low code development platform of the embodiment of the present application.

The processor 1202 may employ a general-purpose central processing unit (central processing unit, CPU), microprocessor, application specific integrated circuit (application specific integrated circuit, ASIC), graphics processor (graphics processing unit, GPU) or one or more integrated circuits for executing associated programs to perform functions required by the elements in the data processing apparatus of the low-code development platform of the present embodiment or to perform the various steps of the data processing method of the low-code development platform of the present embodiment.

The processor 1202 may also be an integrated circuit chip with signal processing capabilities. In implementation, various steps of the data processing method of the low code development platform provided in the present application may be completed by instructions in the form of integrated logic circuits or software of hardware in the processor 1202. The processor 1202 described above may also be a general purpose processor, a digital signal processor (digital signal processing, DSP), an Application Specific Integrated Circuit (ASIC), an off-the-shelf programmable gate array (field programmable gate array, FPGA) or other programmable logic device, discrete gate or transistor logic device, discrete hardware components. The disclosed methods, steps, and logic blocks in the embodiments of the present application may be implemented or performed. A general purpose processor may be a microprocessor or the processor may be any conventional processor or the like. The steps of a method disclosed in connection with the embodiments of the present application may be embodied directly in hardware, in a decoded processor, or in a combination of hardware and software modules in a decoded processor. The software modules may be located in a random access memory, flash memory, read only memory, programmable read only memory, or electrically erasable programmable memory, registers, etc. as well known in the art. The storage medium is located in the memory 1201, and the processor 1202 reads information in the memory 1201, and in combination with hardware thereof, performs functions to be executed by units included in the data processing apparatus of the low-code development platform of the method embodiment of the present application, or executes the data processing method of the low-code development platform of the method embodiment of the present application.

The communication interface 1203 uses a transceiver means such as, but not limited to, a transceiver to enable communication between the device shown in fig. 12 and other devices or communication networks.

The communication bus 1204 may include a path to transfer information between various components of the device shown in fig. 12 (e.g., memory 1201, processor 1202, communication interface 1203).

The embodiment of the application provides a computer readable storage medium, which comprises computer instructions, wherein the computer instructions are used for realizing the technical scheme of the data processing method of any low-code development platform in the embodiment of the application when being executed by a processor.

From the above description of embodiments, those skilled in the art will readily appreciate that the example embodiments described herein may be implemented in software, or may be implemented in software in combination with the necessary hardware. Thus, the technical solution according to the embodiments of the present disclosure may be embodied in the form of a software product, which may be stored on a computer readable medium, including several instructions to cause a computing device (which may be a personal computer, a server, a terminal device, or a network device, etc.) to perform the method according to the embodiments of the present disclosure.

In one typical configuration, a computing device includes one or more processors (CPUs), input/output interfaces, network interfaces, and memory.

The memory may include volatile memory in a computer-readable medium, random Access Memory (RAM) and/or nonvolatile memory, such as Read Only Memory (ROM) or flash memory (flash RAM). Memory is an example of computer-readable media.

Computer readable media, including both non-transitory and non-transitory, removable and non-removable media, may implement information storage by any method or technology. The information may be computer readable instructions, data structures, modules of a program, or other data. Examples of storage media for a computer include, but are not limited to, phase change memory (PRAM), static Random Access Memory (SRAM), dynamic Random Access Memory (DRAM), other types of Random Access Memory (RAM), read Only Memory (ROM), electrically Erasable Programmable Read Only Memory (EEPROM), flash memory or other memory technology, compact disc read only memory (CD-ROM), digital Versatile Discs (DVD) or other optical storage, magnetic cassettes, magnetic tape magnetic disk storage or other magnetic storage media, or any other non-transmission media, that can be used to store information that can be accessed by a computing device. Computer readable media, as defined herein, does not include non-transitory computer readable media (transmission media), such as modulated data signals and carrier waves.

It will be appreciated by those skilled in the art that embodiments of the present application may be provided as a method, system, or computer program product. Accordingly, the present application may take the form of an entirely hardware embodiment, an entirely software embodiment or an embodiment combining software and hardware aspects. Furthermore, the present application may take the form of a computer program product embodied on one or more computer-usable storage media (including, but not limited to, disk storage, CD-ROM, optical storage, and the like) having computer-usable program code embodied therein.

While the preferred embodiment has been described, it is not intended to limit the invention thereto, and any person skilled in the art may make variations and modifications without departing from the spirit and scope of the present invention, so that the scope of the present invention shall be defined by the claims of the present application.

Claims

1. A data processing method for a low-code development platform, applied to the low-code development platform, wherein the low-code development platform is associated with at least one entity, the entity comprising a first attribute and a first logic, the first attribute and the first logic having a first reference relationship, the method comprising:

Obtaining information of the entity, wherein the information comprises: a first domain-specific language corresponding to the entity, a second domain-specific language corresponding to the first attribute, and a third domain-specific language corresponding to the first logic;

rendering in a canvas displayed by the low code development platform according to the information to generate a plurality of nodes, wherein the nodes comprise: the entity node corresponding to the entity, the first attribute node corresponding to the first attribute and the first logic node corresponding to the first logic;

generating a first type of connection line in the canvas in response to a selection operation for the first attribute node or the first logical node, wherein the first type of connection line comprises: a first connection line for representing the first reference relationship.

2. The method of claim 1, wherein the step of determining the position of the substrate comprises,

the entity node stores an entity identification indicating a first storage location, wherein the first storage location stores the first domain-specific language;

the first attribute node stores a first attribute identification indicating a second storage location, wherein the second storage location stores the second domain-specific language, the second domain-specific language including the first reference relationship;

The first logical node stores a first logical identification indicating a third storage location, wherein the third storage location stores the third domain-specific language, the third domain-specific language including the first reference relationship;

wherein the storage space accessed by the low code platform includes the first storage location, the second storage location, and the third storage location.

3. The method of claim 1 or 2, wherein any one of the plurality of nodes is in a collapsed state or an expanded state;

the entity node in the folded state displays partial content included in the first domain-specific language; or, the entity node in the unfolded state displays all contents included in the first domain-specific language;

the first attribute node in the folded state displays part of the content included in the second domain-specific language; or, the first attribute node in the expanded state displays all contents included in the second domain-specific language;

the first logic node in the folded state displays part of the content included in the third domain-specific language; alternatively, the first logical node in the expanded state displays all content included in the third domain-specific language.

4. A method according to any one of claims 1 to 3, wherein said obtaining information of said entity comprises:

acquiring the first domain-specific language from a first storage position in a storage space accessed by the low-code development platform according to an entity identifier corresponding to the entity, wherein the entity identifier indicates the first storage position;

acquiring the second domain-specific language from a second storage position in the storage space according to a first attribute identifier corresponding to the first attribute, wherein the first attribute identifier indicates the second storage position;

and acquiring the third domain-specific language from a third storage position in the storage space according to a first logic identifier corresponding to the first logic, wherein the first logic identifier indicates the third storage position.

5. The method of claim 4, wherein the canvas is located in a first region of the low code development platform, a second region of the low code development platform displays a component list, a primary catalog of the component list displays entity components corresponding to the entities, and a secondary catalog of the component list displays first attribute components corresponding to the first attributes and first logic components corresponding to the first logic; the sub-components of the entity component include the first attribute component and the first logic component;

Before the obtaining the information of the entity, the method further comprises:

creating the canvas in the first region in response to a selection operation for the entity component;

according to the entity component, the following identification associated with the entity component is obtained: the entity identity, the first attribute identity, and the first logical identity.

6. The method of any of claims 1 to 5, wherein rendering the canvas displayed at the low code development platform according to the information generates a plurality of nodes, comprising:

rendering in the canvas according to initial position information and the information to generate the plurality of nodes, wherein the initial position information is used for indicating that the plurality of nodes are positioned at least one position in the canvas;

and adjusting the positions of the nodes at the at least one position according to a layout algorithm, so that the positions of any one of the nodes in the canvas are set according to the positions specified by the layout algorithm.

7. The method of claim 6, wherein adjusting the locations of the plurality of nodes at the at least one location according to a layout algorithm such that the location of any one of the plurality of nodes in the canvas is set according to the location specified by the layout algorithm comprises:

According to the layout algorithm, the following operations are executed:

adjusting the position of the entity node at the at least one position so that the entity node is located in the middle area of the canvas;

adjusting the position of the first logical node at the at least one position so that the first logical node is located in the left area of the entity node;

adjusting the position of the first attribute node at the at least one position so that the first attribute node is located in the right area of the entity node;

if the first logic corresponding to the first logic node is a first type logic, the first logic node is specifically located in an upper half area of the left area of the entity node; or if the first logic corresponding to the first logic node is the logic of the first type, the first logic node is specifically located in the lower half area of the left area of the entity node.

8. The method according to claim 6 or 7, wherein before said adjusting the positions of said plurality of nodes at said at least one position according to a layout algorithm, the method further comprises:

Generating a third connecting line between the entity node and the first attribute node in the canvas, wherein the third connecting line is a connecting line of a second type, and the third connecting line represents that the first attribute corresponding to the first attribute node is an attribute included by an entity corresponding to the entity node;

and generating a fourth connecting line between the entity node and the first logic node in the canvas, wherein the fourth connecting line is the connecting line of the second type, and the fourth connecting line represents that the first logic corresponding to the first logic node is logic included by an entity corresponding to the entity node.

9. The method of any of claims 1 to 5, wherein rendering in a canvas displayed by the low code platform generates a plurality of nodes from the information, comprising:

rendering in the canvas according to preset position information and the information to generate the plurality of nodes, wherein the preset position information indicates that the plurality of nodes are located at a plurality of different positions in the canvas, and the plurality of nodes are in one-to-one correspondence with the plurality of different positions.

10. The method of any of claims 1 to 9, wherein the generating a first type of connection line in the canvas in response to a selection operation for the first attribute node or the first logical node comprises:

responding to the selection operation for the first logic node, and obtaining the first reference relation according to a preset field included in the third domain specific language, wherein the first reference relation is stored in the preset field;

the first connection line is generated in the canvas according to the first reference relationship.

11. The method of any of claims 1 to 10, wherein the canvas is located in a first region of the low code development platform, a second region of the low code development platform displays a component list, a primary catalog included in the component list displays entity components corresponding to the entities, and a secondary catalog included in the component list displays first attribute components corresponding to the first attributes and first logic components corresponding to the first logic; the sub-components of the entity component include the first attribute component and the first logic component;

The method further comprises the steps of:

in the event that an update occurs to a domain-specific language corresponding to any one of the plurality of nodes in the canvas, performing the following operations:

rendering the any node in the canvas according to the updated domain-specific language corresponding to the any node; the method comprises the steps of,

updating the components associated with any node, wherein if any node is the entity node, the components associated with any node are the entity components; if any node is the first attribute node, the component associated with any node is the first attribute component; or if any node is the first logical node, the component associated with the any node is the first logical component.

12. The method of any of claims 1 to 11, wherein after the generating a first type of connection line in the canvas in response to the selecting operation for the first attribute node or the first logical node, the method further comprises:

responding to the satisfaction of preset conditions, and adjusting the positions of nodes in the canvas according to a layout algorithm, so that the nodes in the canvas are set according to the positions specified by the layout algorithm;

Wherein, the meeting the preset condition includes at least one of the following conditions: deleting any node in the plurality of nodes, changing the size of any node, and generating a new node in the canvas; the size of any node is associated with the content displayed by the any node, and the new node is a node corresponding to a new attribute included by the entity or a node corresponding to a new logic included by the entity.

13. The method of any one of claims 1 to 12, wherein the entity further comprises a second logic, wherein the second logic and the first logic have a second reference relationship,

the information further includes: a fourth domain-specific language corresponding to the second logic; the plurality of nodes further includes: a second logical node corresponding to the second logic; the first type of connection line further comprises: and a second connection line for representing the second reference relationship.

14. The method according to any one of claims 1 to 13, wherein,

the first reference relationship is a reference relationship in which the first logic references the first attribute, wherein the first connection line specifically represents a connection line directed to the first attribute node by the first logic node, or the first connection line specifically represents a connection line directed to the first logic node by the first attribute node.

15. A data processing apparatus for a low code platform, the apparatus being applied to a low code development platform, wherein the low code development platform is associated with at least one entity, the entity comprising a first attribute and a first logic, the first attribute and the first logic having a first reference relationship, the apparatus comprising:

the acquisition unit is used for: obtaining information of the entity, wherein the information comprises: a first domain-specific language corresponding to the entity, a second domain-specific language corresponding to the first attribute, and a third domain-specific language corresponding to the first logic;

the processing unit is used for: rendering in a canvas displayed by the low code development platform according to the information to generate a plurality of nodes, wherein the nodes comprise: the entity node corresponding to the entity, the first attribute node corresponding to the first attribute and the first logic node corresponding to the first logic;

the processing unit is further configured to: generating a first type of connection line in the canvas in response to a selection operation for the first attribute node or the first logical node, wherein the first type of connection line comprises: a first connection line for representing the first reference relationship.

16. An electronic device, comprising: a memory and a processor, the memory and the processor coupled;

the memory is used for storing one or more computer instructions;

the processor is configured to execute the one or more computer instructions to implement the method of any of claims 1 to 14.

17. A computer readable storage medium having stored thereon one or more computer instructions executable by a processor to implement the method of any of claims 1 to 14.