I would go work option 1. You will always have a purchase, but not always a matching refund. This way you could foreign key refund to an existing purchase on purchase_id; to ensure valid purchase exists for the refund. Whereas with option 2, you could not foreign key purchase to to refund, as it would not exist yet. If you tried to go this route, you’d have to insert a row into refund when that happens, and then also turn around and update purchase with that info. As for how easy to see what has a refund or not, you can always create views for that.

Almost every "Table-per-Thing" design is a Bad Idea. You almost always wind up having to join across [all] those tables and having lots of Tables in there makes life very difficult. And, if you ever have to change the table structure, say, to add a new column, you have to run the alter table lots and lots of times. Tedious. You should be looking to load all of these CSVs into a single table, keyed on zipcode, address and timestamp (or some combination(s) thereof, depending on how you need to retrieve this data), plus the data field. create table all_data ( zipcode ... , address ... , timestamp ... , data_value , primary key ( zipcode, address, timestamp ) , index( timestamp, zipcode, address ) ); You don't say what's in that data field, but if it's a big chunk of stuff that you might want to query parts of, consider breaking those parts out into individual fields as well. Yes, you can have "complex" data in columns these days, but there's [still] a cost (performance hit) to doing so. I'd suggest using an intermediate table to do the loading, and do some checks on the data as it comes in, before it gets loaded into the table proper. Even if you had a million such these files, you'd still only be looking at around 8 billion records - and that's nothing to a decently-sized PostgreSQL cluster.

There should be a university table to which the auditorium table should refer rather than repeating the uni's data for each auditorium of that uni.

Option 1 (Group focused) If you're set on having having groups, you're going to need a table called Group to control the flow to next question groups, based on answers to questions within the current group. You would then want to create a foreign key between Group.ID and Questionaire.GroupID to ensure each Questionnaire is tied to a valid group. Group Table ID INT NextGroupIfTrue INT NextGroupIfFalse INT 1 2 3 2 3 4 3 5 6 Try to make your group logic as simple as possible. For example, an answer of "yes" to any question in the current group triggers group 'x' as the next group, otherwise go to group 'y'. Your logic (either in a stored procedure or application code) could then be to check if a condition exists within the answers to the questions of the current group, if condition is found to be 'true' follow the next group branch for true, otherwise follow the false branch. Option 2 (Question focused) Ditch the group concept and control next question flow at the question level. Take the same concept as mentioned above in the Group scenario, but list a next question branch for each question directly in the Questionnaire table. For example, if the answer to question 1 is True, go to question 2, else go to question 4. Summary In either case, you're going to want to be able to make a simple boolean decision at either the question or group level, and avoid mismatching the two. Otherwise you're going to need to look into using some form of dynamic SQL generation at each decision is needed, which means you'll be maintaining the underlying code every time a question or group is added or removed.

Start with one table for each of those two "forms". After you have tentative SELECTs and "reporting" requirements and volume estimates. Then we can discuss normalization, many-to-many tables, etc. Also, learn about EAV schema design and be sure to learn why it is not a panacea. (Then I won't have to lecture you when you come back.) There are some examples of CRM in this forum and in stackoverflow.com

There is essentially no reason to prefix tables with the database they are in. Ditto for prefixing column names with the table names. Keep in mind that these syntaxes can give you an equal amount of clutter, without threatening the max name lengths: dbname.tablename tablename.columnname "Everybody" recognizes genus_species; I suggest that is sufficient for that table.

I've seen it mentioned in blogs and tutorials that a weak entity "doesn't have a primary key," but this is misleading. You are correct that every table needs a primary key. This is necessary for the table to qualify as a relation. Every relation has one or more candidate keys, and one of the candidate keys is chosen as the table's primary key. The meaning of a candidate key is that the columns are non-NULL and they can be used to uniquely identify any row in the table. The term weak entity is used for a table where the rows cannot exist without referencing some "parent" entity. For example, you might have tables Users and Phones such that a user can have zero, one, or multiple phones. But a phone number cannot exist without referencing its owning user. Therefore Users is a strong entity; one row in the Users table can exist without regard to how many phones it has, or even if no phones reference it. Phones is a weak entity. A given phone number cannot exist unless it references a row in Users. A good way to implement this in SQL is to require that the primary key of the Phones table include a reference to the primary key of a row in User. But a user may own multiple phones, so there needs to be an additional column in Phones to make it a compound primary key. This is often called the discriminator and it's just an arbitrary value that serves to be distinct for each of the phones belonging to a given user. It doesn't necessarily have any other meaning, but sometimes people use it as an ordinal number for displaying the phones. Example: CREATE TABLE Phones ( owner_id INT NOT NULL, phone_ordinal INT NOT NULL, phone_number VARCHAR(32) NOT NULL, phone_type VARCHAR(16) NOT NULL, PRIMARY KEY (owner_id, phone_ordinal), FOREIGN KEY (owner_id) REFERENCES Users(user_id) ); Some people state this as "Phones doesn't have a primary key" but they mean it doesn't have its own auto-incrementing integer column. It depends on values in the primary key of the Users table. Many software developers confuse "primary key" with "an auto-incrementing integer column named id." This is a misunderstanding of what a primary key is. A primary key is a constraint applied to one or more columns, which together are a candidate key for the table. It does not necessarily mean the primary key is a single column, or that it is an integer, or that it is auto-incrementing. P.S. I want to be clear that using auto-increment for a primary key is not the criterion for a strong entity. Auto-increment is not required by the relational model at all, it's just a convenience that is popular.

Did some more research....I guess these details are already stored in a catalog view that you can just query: SELECT T.name TableName,i.Rows NumberOfRows FROM sys.tables T JOIN sys.sysindexes I ON T.OBJECT_ID = I.ID WHERE indid IN (0,1) AND t.name LIKE '%20170101%' ORDER BY i.Rows DESC,T.name

These are called System Catalogs. And https://www.postgresql.org/docs/current/catalogs.html says that they are represented by regular tables in PostgreSQL: The system catalogs are the place where a relational database management system stores schema metadata, such as information about tables and columns, and internal bookkeeping information. PostgreSQL's system catalogs are regular tables. You can drop and recreate the tables, add columns, insert and update values, and severely mess up your system that way. Normally, one should not change the system catalogs by hand, there are normally SQL commands to do that. (For example, CREATE DATABASE inserts a row into the pg_database catalog — and actually creates the database on disk.) There are some exceptions for particularly esoteric operations, but many of those have been made available as SQL commands over time, and so the need for direct manipulation of the system catalogs is ever decreasing.

<table> <tr> <th>1</th> <th>2</th> </tr> <tr> <td class="td-value" style="background-color: #E59B9A;"> <div style="background-color: #E59B9A;"> <span class="class-name">ЛФК</span> <span class="class-description">09:00- 09:55 (55 мин.) Зал ГП №1</span> </div> <div style="background-color: #FDE05D;"> <span class="class-name">ЛФК</span> <span class="class-description">09:00- 09:55 (55 мин.) Зал ГП №1</span> </div></td> <td class="td-value" style="height: 1px;"><div style="background-color: #FDE05D; height:100%;"> <span class="class-name">FUNCTIONAL TRAINING</span> <span class="class-description">13:00- 13:55 (55 мин.) Зал ГП №1</span> </div></td> </tr> </table>

The crust may be produced by the same for loop, i.e. Your code will be: *Список содержащий кортежи* result = [(1, 'ivan', 36), (2, 'oleg', 31), (3, 'dima', 27)]. # --------------------- &lt;table&gt; &lt;tr&gt; &lt;th&gt;id&lt;/th&gt; &lt;th&gt;name&lt;/th&gt; &lt;th&gt;age&lt;/th&gt; &lt;/tr {% for user in users %} &lt;tr&gt; {% for item in user %} &lt;td&gt;{{ item }}&lt;/td&gt; {% endfor %} &lt;/tr&gt; {% endfor %} &lt;/table&gt;

<table> <tr> <th>id</th> <th>name</th> <th>age</th> </tr> {% for user in users %} <tr> <td>{{ user.0 }}</td> <td>{{ user.1 }}</td> <td>{{ user.2 }}</td> </tr> {% endfor %} </table>

Operator ... is only suitable for copying the masses of simple types. As the elements of the mass data these are objects, [...data] not creating a new body.

I see the target, I see no obstacles.Reading. https://basicweb.ru/html/tag_td_att_colspan.php and https://basicweb.ru/html/tag_td_att_rowspan.php ♪ We' it. https://apsolyamov.ru/files/html-table-generator.html ♪table { border-collapse: collapse; } td, th { padding: .5em; border: 1px solid #000; font-family: sans-serif; text-align: center; }<table> <tr> <th colspan="7">Пакетные услуги по образованию</th> </tr> <tr> <td rowspan="4">#</td> <th rowspan="4">Обучение (образование)</td> <th rowspan="4">Стоимость на 1-го человека</th> <th colspan="4">ПАКЕТЫ</th> </tr> <tr> <th>базовый</th> <th>бронзовый</th> <th>серебряный</th> <th>золотой</th> </tr> <tr> <td>20 - 30 человек на одном курсе</td> <td>от 31 человека на одном курсе</td> <td>от 76 человек на одном курсе</td> <td>свыше 120 человека на одном курсе</td> </tr> <tr> <td colspan="4">скидки по пакетам для рынка (продажи оплачиваются отдельно)</td> </tr> </table>

To replace the variable in the line, use it. https://developer.mozilla.org/ru/docs/Web/JavaScript/Reference/Template_literals :var massive = []; for(let i = 1; i < RowsCount; i++) { var Item_Name = document.querySelector(#table &gt; tr:nth-child(${i}) &gt; td.copy-name).textContent; var Item_Href = document.querySelector(#table &gt; tr:nth-child(${i}) &gt; td:nth-child(3) &gt; a).href; var Item_Cost = document.querySelector(#table &gt; tr:nth-child(${i}) &gt; td:nth-child(3) &gt; div &gt; div &gt; div &gt; span:nth-child(5) &gt; div:nth-child(2)).textContent; massive.push([Item_Name, Item_Href, Item_Cost]); }

const app = new Vue({ el: "#app", data() { return { employes: [{ "id": 11, "name": "Юль", "surname": "Кутаева", "middle_name": "Лукашенко", departments_id: [8, 9] }, { "id": 14, "name": "sdcsdc", "surname": "sdcsdc", "middle_name": "sdcsdc", departments_id: [8] } ], departments: [{ "id": 8, "name": "Кухарки", }, { "id": 9, "name": "Коты", } ] }; }, });<script src="https://cdn.jsdelivr.net/npm/vue@2.6.0"></script> <div id="app"> <table cellspacing="10"> <thead> <tr> <th>Name</th> <th v-for="dep in departments">{{dep.name}}</th> </tr> </thead> <tbody> <tr v-for="item in employes"> <td>{{${item.name} ${item.middle_name} ${item.surname}}}</td> <td v-for="dep in departments" :bgcolor="item.departments_id.includes(dep.id) ? 'red' : ''"></td> </tr> </tbody> </table> </div>

Here's an example, you didn't get th because you don't have it in the back.table tr:first-child{ background: #ccc; }<table class="calltable" id="calltable"> <!--Заголовок таблицы--> <tr> <td> № </td> <td> Дата/Время </td> <td> Входящий абонент </td> <td> Телефон входящего абонента </td> <td> Исходящий абонент </td> <td> Телефон исходящего абонента </td> <td> Продолжительность </td> <td> Оператор абонента </td> <td> Стоимость вызова </td> </tr> <tr> <td> 1 </td> <td> 1111 </td> <td> 1111 </td> <td> 2222 </td> <td> 2222 </td> <td> 1111 </td> <td> 1 </td> <td> 1 </td> <td> 1 </td> </tr> <table>

I think the table should have lists/corriges, and in cases of vocabulary, it should be visible.Plus, the number of columns, the use of the body as a vocabulary, there's gonna be two, I think we need to support an arbitrary number of columns. https://github.com/gil9red/SimplePyScripts/blob/21ab50c6f081e71d8e6342a12cefe035f54396ff/ascii_table__simple_pretty__rjust.py#L7 def pretty_table(data, cell_sep=' | ', header_separator=True) -> str: rows = len(data) cols = len(data[0]) col_width = [] for col in range(cols): columns = [str(data[row][col]) for row in range(rows)] col_width.append(len(max(columns, key=len))) separator = "-+-".join('-' * n for n in col_width) lines = [] for i, row in enumerate(range(rows)): result = [] for col in range(cols): item = str(data[row][col]).rjust(col_width[col]) result.append(item) lines.append(cell_sep.join(result)) if i == 0 and header_separator: lines.append(separator) return '\n'.join(lines) Use:data = [ ["Категории", "Цена"], {"book": 58, "organization": 0, "homegum": 55, "summer": 1, "win": 85189} ] rows = [ data[0] ] rows += [(k, v) for k, v in data[1].items()] print(pretty_table(rows)) Result: Категории | Цена -------------+------ book | 58 organization | 0 homegum | 55 summer | 1 win | 85189

Problem was, the uniform didn't sabotage the server. The button wasn't in shape.

Why did you save a bunch of unnecessary code? I recommend reading http://htmlbook.ru/css/border-collapse ♪.calltable { margin-top: 30px; /* border: 2px solid royalblue; <-- урбрать */ border-collapse: collapse; /* <-- добавить */ } .calltable td { padding-left: 25px; padding-right: 25px; font-weight: bold; border: 2px solid royalblue; }<table class="calltable"> <th> <td> № </td> <td> Дата/Время </td> <td> Входящий абонент </td> <td> Телефон входящего абонента </td> <td> Исходящий абонент </td> <td> Телефон исходящего абонента </td> <td> Продолжительность </td> <td> Оператор абонента </td> <td> Стоимость вызова </td> </th> </table>