CREATE TABLE example_table (
    id serial PRIMARY KEY,
    text_data varchar2(4000)
);

SELECT * FROM your_table_name
LIMIT 10 OFFSET 5;

custom:
  users:
    - name: user1
      age: 30
    - name: user2
      age: 25
  mappings:
    key1: value1
    key2: value2

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Configuration;
import java.util.List;
import java.util.Map;

@Configuration
@ConfigurationProperties(prefix = "custom")
public class CustomProperties {
    private List<User> users;
    private Map<String, String> mappings;

    // standard getters and setters
    public List<User> getUsers() {
        return users;
    }

    public void setUsers(List<User> users) {
        this.users = users;
    }

    public Map<String, String> getMappings() {
        return mappings;
    }

    public void setMappings(Map<String, String> mappings) {
        this.mappings = mappings;
    }

    public static class User {
        private String name;
        private int age;

        // standard getters and setters
        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public int getAge() {
            return age;
        }

        public void setAge(int age) {
            this.age = age;
        }
    }
}

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;
import java.util.Map;

@Service
public class MyService {

    @Autowired
    private CustomProperties customProperties;

    public void printCustomProperties() {
        List<CustomProperties.User> users = customProperties.getUsers();
        for (CustomProperties.User user : users) {
            System.out.println("Name: " + user.getName() + ", Age: " + user.getAge());
        }

        Map<String, String> mappings = customProperties.getMappings();
        for (Map.Entry<String, String> entry : mappings.entrySet()) {
            System.out.println("Key: " + entry.getKey() + ", Value: " + entry.getValue());
        }
    }
}

npm install -g @vue/cli
vue create my-project

cd my-project
npm install element-ui --save

import Vue from 'vue'
import ElementUI from 'element-ui'
import 'element-ui/lib/theme-chalk/index.css'
import App from './App.vue'

Vue.use(ElementUI)

new Vue({
  el: '#app',
  render: h => h(App)
})

<template>
  <div>
    <el-button type="primary">点击我</el-button>
  </div>
</template>

<script>
export default {
  // 组件逻辑
}
</script>

class DatabaseWriter : public QThread
{
    Q_OBJECT

public:
    DatabaseWriter(QObject *parent = nullptr) : QThread(parent) {}

    void run() override {
        // 数据库写入操作
        // 例如：
        // QSqlQuery query(QSqlDatabase::database());
        // query.exec("INSERT INTO table_name (column1, column2) VALUES (value1, value2)");
    }

signals:
    void error(const QString &message);
    void finished();

public slots:
    void writeData(const QVariant &data) {
        // 数据处理和准备
        // 例如：
        // QVariant data = ...
        // 在这里可以对data进行处理

        // 数据库写入操作
        // 例如：
        // QSqlQuery query(QSqlDatabase::database());
        // query.exec("INSERT INTO table_name (column1, column2) VALUES (value1, value2)");

        // 如果写入成功，发送finished信号
        emit finished();
    }
};

DatabaseWriter *databaseWriter = new DatabaseWriter(this);
connect(databaseWriter, &DatabaseWriter::finished, this, [this]() {
    // 数据库写入完成后的操作
});
connect(databaseWriter, &DatabaseWriter::error, this, [this](const QString &message)
    // 处理错误信息
});

// 准备数据并开始写入
QVariant data = ...
databaseWriter->writeData(data);

class DatabaseWriter : public QObject
{
    Q_OBJECT

public:
    DatabaseWriter(QObject *parent = nullptr) : QObject(parent) {}

public slots:
    void writeData(const QVariant &data) {
        // 数据处理和准备
        // 例如：
        // QVariant data = ...
        // 在这里可以对data进行处理

        // 数据库写入操作
        // 例如：
        // QSqlQuery query(QSqlDatabase::database());
        // query.exec("INSERT INTO table_name (column1, column2) VALUES (value1, value2)");
    }
};

// 创建QRunnable对象
DatabaseWriter *databaseWriter = new DatabaseWriter(this);
QThread *thread = new QThread(this);
databaseWriter->moveToThread(thread);

// 连接信号和槽以启动写入操作
QVariant data = ...
connect(this, &MainWindow::startWriting, databaseWriter, &DatabaseWriter::writeData);
// 发送startWriting信号

-- 创建测试表
CREATE TABLE test_lock (id SERIAL PRIMARY KEY, value VARCHAR(50));

-- 插入一些数据
INSERT INTO test_lock (value) VALUES ('A'), ('B'), ('C');

-- 在会话1中开启一个事务并对表加排他锁
BEGIN;
LOCK TABLE test_lock IN ACCESS EXCLUSIVE MODE;
-- 此处会话1会被挂起，直至会话2释放锁

-- 在另一个会话（会话2）中检查锁等待信息
SELECT pid, mode, granted, m.relname
FROM pg_locks l
JOIN pg_class m ON l.relation = m.oid
JOIN pg_stat_activity a ON a.pid = l.pid
WHERE m.relname = 'test_lock';

-- 结果将显示会话1对表的排他锁等待中，以及锁的类型、是否已获得授权等信息

SELECT table_name FROM user_tables;

SELECT table_name FROM all_tables WHERE owner = '目标用户名';

-- 创建用户
CREATE USER myuser IDENTIFIED BY mypassword;

-- 授予查询权限
GRANT SELECT ANY TABLE TO myuser;

-- 如果需要，可以授予对特定表的查询权限
GRANT SELECT ON schema_name.table_name TO myuser;

-- 如果需要，可以授予对特定视图的查询权限
GRANT SELECT ON schema_name.view_name TO myuser;

-- 如果需要，可以授予对特定序列的查询权限
GRANT SELECT ON schema_name.sequence_name TO myuser;

-- 创建只读用户
CREATE USER read_only_user IDENTIFIED BY read_only_password;

-- 给予只读用户权限
GRANT CONNECT TO read_only_user;
GRANT RESOURCE TO read_only_user;

-- 限制只读用户的数据访问
ALTER USER read_only_user QUOTA UNLIMITED ON users;

-- 授予只读权限
GRANT SELECT ANY TABLE TO read_only_user;