@lightdash/warehouses 2.228.1 → 2.229.1

package/dist/warehouseClients/PostgresWarehouseClient.test.js

@@ -1,371 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-/* eslint-disable prefer-arrow-callback, func-names */
-const pg = __importStar(require("pg"));
-const stream_1 = require("stream");
-const PostgresWarehouseClient_1 = require("./PostgresWarehouseClient");
-const PostgresWarehouseClient_mock_1 = require("./PostgresWarehouseClient.mock");
-const WarehouseClient_mock_1 = require("./WarehouseClient.mock");
-vi.mock('pg', async () => ({
-    ...(await vi.importActual('pg')).default,
-    Pool: vi.fn(function () {
-        return {
-            connect: vi.fn((callback) => {
-                callback(null, {
-                    query: vi.fn((arg) => {
-                        // Session statements (SET statement_timeout / timezone)
-                        // are issued as plain string queries and must return a
-                        // thenable, not a stream.
-                        if (typeof arg === 'string') {
-                            return Promise.resolve({
-                                rows: [],
-                                fields: [],
-                            });
-                        }
-                        const mockedStream = new stream_1.PassThrough();
-                        setTimeout(() => {
-                            mockedStream.emit('data', {
-                                row: WarehouseClient_mock_1.expectedRow,
-                                fields: PostgresWarehouseClient_mock_1.queryColumnsMock,
-                            });
-                            mockedStream.end();
-                        }, 100);
-                        return mockedStream;
-                    }),
-                    on: vi.fn(async () => undefined),
-                }, vi.fn());
-            }),
-            end: vi.fn(async () => undefined),
-            on: vi.fn(async () => undefined),
-        };
-    }),
-}));
-describe('PostgresWarehouseClient', () => {
-    it('expect query rows', async () => {
-        const warehouse = new PostgresWarehouseClient_1.PostgresWarehouseClient(PostgresWarehouseClient_mock_1.credentials);
-        const results = await warehouse.runQuery('fake sql');
-        expect(results.fields).toEqual(WarehouseClient_mock_1.expectedFields);
-        expect(results.rows[0]).toEqual(WarehouseClient_mock_1.expectedRow);
-    });
-    it('expect schema with postgres types mapped to dimension types', async () => {
-        const warehouse = new PostgresWarehouseClient_1.PostgresWarehouseClient(PostgresWarehouseClient_mock_1.credentials);
-        pg.Pool
-            .mockImplementationOnce(function () {
-            return {
-                connect: vi.fn((callback) => {
-                    callback(null, {
-                        query: vi.fn((arg) => {
-                            if (typeof arg === 'string') {
-                                return Promise.resolve({
-                                    rows: [],
-                                    fields: [],
-                                });
-                            }
-                            const mockedStream = new stream_1.PassThrough();
-                            setTimeout(() => {
-                                mockedStream.emit('data', {
-                                    row: { version: 'PostgreSQL 15.4' },
-                                    fields: [],
-                                });
-                                mockedStream.end();
-                            }, 100);
-                            return mockedStream;
-                        }),
-                        on: vi.fn(async () => undefined),
-                    }, vi.fn());
-                }),
-                end: vi.fn(async () => undefined),
-                on: vi.fn(async () => undefined),
-            };
-        })
-            .mockImplementationOnce(function () {
-            return {
-                connect: vi.fn((callback) => {
-                    callback(null, {
-                        query: vi.fn((arg) => {
-                            if (typeof arg === 'string') {
-                                return Promise.resolve({
-                                    rows: [],
-                                    fields: [],
-                                });
-                            }
-                            const mockedStream = new stream_1.PassThrough();
-                            setTimeout(() => {
-                                PostgresWarehouseClient_mock_1.columns.forEach((column) => {
-                                    mockedStream.emit('data', {
-                                        row: column,
-                                        fields: [],
-                                    });
-                                });
-                                mockedStream.end();
-                            }, 100);
-                            return mockedStream;
-                        }),
-                        on: vi.fn(async () => undefined),
-                    }, vi.fn());
-                }),
-                end: vi.fn(async () => undefined),
-                on: vi.fn(async () => undefined),
-            };
-        });
-        expect(await warehouse.getCatalog(WarehouseClient_mock_1.config)).toEqual(WarehouseClient_mock_1.expectedWarehouseSchemaWithNaiveTimestamp);
-    });
-    it('expect empty catalog when dbt project has no references', async () => {
-        const warehouse = new PostgresWarehouseClient_1.PostgresWarehouseClient(PostgresWarehouseClient_mock_1.credentials);
-        expect(await warehouse.getCatalog([])).toEqual({});
-    });
-    it('binds catalog filter values as query parameters', async () => {
-        const warehouse = new PostgresWarehouseClient_1.PostgresWarehouseClient(PostgresWarehouseClient_mock_1.credentials);
-        const database = "missing') OR (SELECT CAST(current_database() AS integer)=0) OR ('x'='x";
-        const runQuery = vi
-            .spyOn(warehouse, 'runQuery')
-            .mockResolvedValueOnce({
-            rows: [{ version: 'PostgreSQL 15.4' }],
-            fields: {},
-        })
-            .mockResolvedValueOnce({ rows: [], fields: {} });
-        await warehouse.getCatalog([
-            { database, schema: 'public', table: 'orders' },
-        ]);
-        const catalogQuery = runQuery.mock.calls[1][0];
-        expect(catalogQuery).toContain('table_catalog IN ($1)');
-        expect(catalogQuery).toContain('table_schema IN ($2)');
-        expect(catalogQuery).toContain('table_name IN ($3)');
-        expect(catalogQuery).not.toContain(database);
-        expect(runQuery.mock.calls[1][3]).toEqual([
-            database,
-            'public',
-            'orders',
-        ]);
-    });
-    describe('getAllTables', () => {
-        it('lists tables, views and materialized views', async () => {
-            const warehouse = new PostgresWarehouseClient_1.PostgresWarehouseClient(PostgresWarehouseClient_mock_1.credentials);
-            const runQuery = vi
-                .spyOn(warehouse, 'runQuery')
-                .mockResolvedValueOnce({
-                rows: [{ version: 'PostgreSQL 15.4' }],
-                fields: {},
-            })
-                .mockResolvedValueOnce({
-                rows: [
-                    {
-                        table_catalog: 'warehouse',
-                        table_schema: 'public',
-                        table_name: 'orders_view',
-                        table_type: 'VIEW',
-                    },
-                    {
-                        table_catalog: 'warehouse',
-                        table_schema: 'public',
-                        table_name: 'orders_mv',
-                        table_type: 'MATERIALIZED VIEW',
-                    },
-                ],
-                fields: {},
-            });
-            const tables = await warehouse.getAllTables();
-            const [query] = runQuery.mock.calls[1];
-            expect(query).toContain("table_type IN ('BASE TABLE', 'VIEW', 'FOREIGN')");
-            expect(query).toContain('FROM pg_catalog.pg_matviews');
-            expect(tables).toEqual([
-                {
-                    database: 'warehouse',
-                    schema: 'public',
-                    table: 'orders_view',
-                    tableType: 'view',
-                },
-                {
-                    database: 'warehouse',
-                    schema: 'public',
-                    table: 'orders_mv',
-                    tableType: 'materialized_view',
-                },
-            ]);
-        });
-        it('skips pg_matviews on servers that predate it', async () => {
-            const warehouse = new PostgresWarehouseClient_1.PostgresWarehouseClient(PostgresWarehouseClient_mock_1.credentials);
-            const runQuery = vi
-                .spyOn(warehouse, 'runQuery')
-                .mockResolvedValueOnce({
-                rows: [{ version: 'PostgreSQL 8.0.2' }],
-                fields: {},
-            })
-                .mockResolvedValueOnce({ rows: [], fields: {} });
-            await warehouse.getAllTables();
-            expect(runQuery.mock.calls[1][0]).not.toContain('pg_matviews');
-        });
-    });
-    describe('getFields', () => {
-        it('includes materialized view columns and binds filters in order', async () => {
-            const warehouse = new PostgresWarehouseClient_1.PostgresWarehouseClient(PostgresWarehouseClient_mock_1.credentials);
-            const runQuery = vi
-                .spyOn(warehouse, 'runQuery')
-                .mockResolvedValueOnce({
-                rows: [{ version: 'PostgreSQL 15.4' }],
-                fields: {},
-            })
-                .mockResolvedValueOnce({
-                rows: [
-                    {
-                        table_catalog: 'warehouse',
-                        table_schema: 'public',
-                        table_name: 'orders_mv',
-                        column_name: 'amount',
-                        data_type: 'numeric',
-                    },
-                ],
-                fields: {},
-            });
-            const fields = await warehouse.getFields('orders_mv', undefined, 'warehouse');
-            const [query, , , values] = runQuery.mock.calls[1];
-            expect(query).toContain("c.relkind = 'm'");
-            expect(query).toContain('table_catalog = $2');
-            expect(query).not.toContain('$3');
-            expect(values).toEqual(['orders_mv', 'warehouse']);
-            expect(fields).toEqual({
-                warehouse: { public: { orders_mv: { amount: 'number' } } },
-            });
-        });
-    });
-});
-describe('PostgresWarehouseClient statement timeout', () => {
-    const mockPoolWithQuery = (queryMock) => {
-        pg.Pool.mockImplementationOnce(function () {
-            return {
-                connect: vi.fn((callback) => {
-                    callback(null, { query: queryMock, on: vi.fn() }, vi.fn());
-                }),
-                end: vi.fn(async () => undefined),
-                on: vi.fn(),
-            };
-        });
-    };
-    const respondingQueryMock = () => vi.fn((arg) => {
-        if (typeof arg === 'string') {
-            return Promise.resolve({ rows: [], fields: [] });
-        }
-        const stream = new stream_1.PassThrough();
-        setTimeout(() => {
-            stream.emit('data', {
-                row: WarehouseClient_mock_1.expectedRow,
-                fields: PostgresWarehouseClient_mock_1.queryColumnsMock,
-            });
-            stream.end();
-        }, 10);
-        return stream;
-    });
-    afterEach(() => {
-        vi.useRealTimers();
-    });
-    it('sets a server-side statement_timeout using the 9-minute default ceiling', async () => {
-        const queryMock = respondingQueryMock();
-        mockPoolWithQuery(queryMock);
-        const warehouse = new PostgresWarehouseClient_1.PostgresWarehouseClient(PostgresWarehouseClient_mock_1.credentials);
-        await warehouse.runQuery('select 1');
-        const sessionStatement = queryMock.mock.calls
-            .map((call) => call[0])
-            .find((arg) => typeof arg === 'string');
-        expect(sessionStatement).toContain('SET statement_timeout = 540000');
-    });
-    it('omits the competing pg query_timeout from the pool', async () => {
-        const queryMock = respondingQueryMock();
-        mockPoolWithQuery(queryMock);
-        const warehouse = new PostgresWarehouseClient_1.PostgresWarehouseClient(PostgresWarehouseClient_mock_1.credentials);
-        await warehouse.runQuery('select 1');
-        const poolConfig = pg.Pool.mock.lastCall?.[0];
-        expect(poolConfig).not.toHaveProperty('query_timeout');
-    });
-    it('honors a configured timeoutSeconds for the statement_timeout', async () => {
-        const queryMock = respondingQueryMock();
-        mockPoolWithQuery(queryMock);
-        const warehouse = new PostgresWarehouseClient_1.PostgresWarehouseClient({
-            ...PostgresWarehouseClient_mock_1.credentials,
-            timeoutSeconds: 120,
-        });
-        await warehouse.runQuery('select 1');
-        const sessionStatement = queryMock.mock.calls
-            .map((call) => call[0])
-            .find((arg) => typeof arg === 'string');
-        expect(sessionStatement).toContain('SET statement_timeout = 120000');
-    });
-    it('rejects with a timeout error when a query stalls past the client backstop', async () => {
-        vi.useFakeTimers();
-        const queryMock = vi.fn((arg) => {
-            if (typeof arg === 'string') {
-                return Promise.resolve({ rows: [], fields: [] });
-            }
-            // A stream that never emits or ends — simulates a stalled cursor.
-            return new stream_1.PassThrough();
-        });
-        mockPoolWithQuery(queryMock);
-        const warehouse = new PostgresWarehouseClient_1.PostgresWarehouseClient(PostgresWarehouseClient_mock_1.credentials);
-        const resultPromise = warehouse.runQuery('select pg_sleep(9999)');
-        // Attach the rejection handler before advancing the clock so the
-        // rejection is never momentarily unhandled.
-        await Promise.all([
-            expect(resultPromise).rejects.toThrow('Query timed out after 570s'),
-            // 9-minute statement_timeout + 30s client buffer = 570s
-            vi.advanceTimersByTimeAsync(570 * 1000 + 1000),
-        ]);
-    });
-});
-describe('PostgresSqlBuilder escaping', () => {
-    const postgresSqlBuilder = new PostgresWarehouseClient_1.PostgresSqlBuilder();
-    test('Should not escape regular characters', () => {
-        expect(postgresSqlBuilder.escapeString('%')).toBe('%');
-        expect(postgresSqlBuilder.escapeString('_')).toBe('_');
-        expect(postgresSqlBuilder.escapeString('?')).toBe('?');
-        expect(postgresSqlBuilder.escapeString('!')).toBe('!');
-        expect(postgresSqlBuilder.escapeString('credit_card')).toBe('credit_card');
-    });
-    test('Should escape single quotes in postgres', () => {
-        expect(postgresSqlBuilder.escapeString("single'quote")).toBe("single''quote");
-    });
-    test('Should escape backslashes and quotes in postgres', () => {
-        expect(postgresSqlBuilder.escapeString("\\') OR (1=1) --")).toBe("\\\\'') OR (1=1) ");
-    });
-    test('Should handle SQL injection attempts', () => {
-        // Test with a typical SQL injection pattern
-        const maliciousInput = "'; DROP TABLE users; --";
-        const escaped = postgresSqlBuilder.escapeString(maliciousInput);
-        expect(escaped).toBe("''; DROP TABLE users; ");
-        // Test with another common SQL injection pattern
-        const anotherMaliciousInput = "' OR '1'='1";
-        const anotherEscaped = postgresSqlBuilder.escapeString(anotherMaliciousInput);
-        expect(anotherEscaped).toBe("'' OR ''1''=''1");
-    });
-});

package/dist/warehouseClients/RedshiftWarehouseClient.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=RedshiftWarehouseClient.test.d.ts.map

package/dist/warehouseClients/RedshiftWarehouseClient.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"RedshiftWarehouseClient.test.d.ts","sourceRoot":"","sources":["../../src/warehouseClients/RedshiftWarehouseClient.test.ts"],"names":[],"mappings":""}

package/dist/warehouseClients/RedshiftWarehouseClient.test.js

@@ -1,126 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const common_1 = require("@lightdash/common");
-const RedshiftWarehouseClient_1 = require("./RedshiftWarehouseClient");
-const credentials = {
-    type: common_1.WarehouseTypes.REDSHIFT,
-    host: 'localhost',
-    user: 'analytics',
-    password: 'password',
-    port: 5439,
-    dbname: 'warehouse',
-    schema: 'public',
-    authenticationType: common_1.RedshiftAuthenticationType.PASSWORD,
-};
-const redshiftVersion = {
-    rows: [
-        { version: 'PostgreSQL 8.0.2 on i686-pc-linux-gnu, Redshift 1.0.77' },
-    ],
-    fields: {},
-};
-describe('RedshiftWarehouseClient', () => {
-    it('keeps catalog filters in the Redshift query', async () => {
-        const warehouse = new RedshiftWarehouseClient_1.RedshiftWarehouseClient(credentials);
-        const runQuery = vi
-            .spyOn(warehouse, 'runQuery')
-            .mockResolvedValueOnce({
-            rows: [{ version: 'PostgreSQL 8.0.2' }],
-            fields: {},
-        })
-            .mockResolvedValueOnce({ rows: [], fields: {} });
-        await warehouse.getCatalog([
-            { database: 'warehouse', schema: 'public', table: 'orders' },
-        ]);
-        const catalogQuery = runQuery.mock.calls[1][0];
-        expect(catalogQuery).toContain("table_catalog IN ('warehouse')");
-        expect(catalogQuery).toContain("table_schema IN ('public')");
-        expect(catalogQuery).toContain("table_name IN ('orders')");
-        expect(runQuery.mock.calls[1][3]).toBeUndefined();
-    });
-    it('lists tables and views from svv_tables scoped to the database', async () => {
-        const warehouse = new RedshiftWarehouseClient_1.RedshiftWarehouseClient(credentials);
-        const runQuery = vi
-            .spyOn(warehouse, 'runQuery')
-            .mockResolvedValueOnce(redshiftVersion)
-            .mockResolvedValueOnce({
-            rows: [
-                {
-                    table_catalog: 'warehouse',
-                    table_schema: 'public',
-                    table_name: 'orders_lbv',
-                    table_type: 'VIEW',
-                },
-                {
-                    table_catalog: 'warehouse',
-                    table_schema: 'spectrum',
-                    table_name: 'sales',
-                    table_type: 'EXTERNAL TABLE',
-                },
-            ],
-            fields: {},
-        });
-        const tables = await warehouse.getAllTables();
-        const [query, , , values] = runQuery.mock.calls[1];
-        expect(query).toContain('FROM svv_tables');
-        expect(query).toContain('table_catalog = $1');
-        expect(values).toEqual(['warehouse']);
-        expect(tables).toEqual([
-            {
-                database: 'warehouse',
-                schema: 'public',
-                table: 'orders_lbv',
-                tableType: 'view',
-            },
-            {
-                database: 'warehouse',
-                schema: 'spectrum',
-                table: 'sales',
-                tableType: 'external',
-            },
-        ]);
-    });
-    it('reads columns from svv_columns so late-binding views resolve', async () => {
-        const warehouse = new RedshiftWarehouseClient_1.RedshiftWarehouseClient(credentials);
-        const runQuery = vi
-            .spyOn(warehouse, 'runQuery')
-            .mockResolvedValueOnce(redshiftVersion)
-            .mockResolvedValueOnce({
-            rows: [
-                {
-                    table_catalog: 'warehouse',
-                    table_schema: 'public',
-                    table_name: 'orders_lbv',
-                    column_name: 'quantity',
-                    data_type: 'integer',
-                },
-            ],
-            fields: {},
-        });
-        const fields = await warehouse.getFields('orders_lbv', 'public', 'warehouse');
-        const [query, , , values] = runQuery.mock.calls[1];
-        expect(query).toContain('FROM svv_columns');
-        expect(values).toEqual(['orders_lbv', 'public', 'warehouse']);
-        expect(fields).toEqual({
-            warehouse: {
-                public: { orders_lbv: { quantity: 'number' } },
-            },
-        });
-    });
-    it('keeps the Postgres catalog when the server is not Redshift', async () => {
-        const warehouse = new RedshiftWarehouseClient_1.RedshiftWarehouseClient(credentials);
-        const runQuery = vi
-            .spyOn(warehouse, 'runQuery')
-            .mockResolvedValueOnce({
-            rows: [{ version: 'PostgreSQL 15.4' }],
-            fields: {},
-        })
-            .mockResolvedValueOnce({ rows: [], fields: {} })
-            .mockResolvedValueOnce({ rows: [], fields: {} });
-        await warehouse.getAllTables();
-        await warehouse.getFields('orders', 'public');
-        expect(runQuery).toHaveBeenCalledTimes(3);
-        expect(runQuery.mock.calls[1][0]).toContain('FROM information_schema.tables');
-        expect(runQuery.mock.calls[1][0]).not.toContain('svv_tables');
-        expect(runQuery.mock.calls[2][0]).toContain('FROM information_schema.columns');
-    });
-});

package/dist/warehouseClients/SnowflakeWarehouseClient.mock.d.ts

@@ -1,41 +0,0 @@
-import { AnyType, CreateSnowflakeCredentials, DimensionType } from '@lightdash/common';
-export declare const credentials: CreateSnowflakeCredentials;
-export declare const columns: Record<string, AnyType>[];
-declare class ColumnMock {
-    private readonly name;
-    private readonly type;
-    private readonly scale;
-    constructor(name: string, type: string, scale?: number);
-    getName(): string;
-    getType(): string;
-    getScale(): number;
-}
-export declare const queryColumnsMock: ColumnMock[];
-export declare const expectedWarehouseSchema: {
-    myDatabase: {
-        mySchema: {
-            myTable: {
-                MYSTRINGCOLUMN: DimensionType;
-                MYNUMBERCOLUMN: DimensionType;
-                MYDATECOLUMN: DimensionType;
-                MYTIMESTAMPCOLUMN: DimensionType;
-                MYBOOLEANCOLUMN: DimensionType;
-                MYARRAYCOLUMN: DimensionType;
-                MYOBJECTCOLUMN: DimensionType;
-            };
-        };
-    };
-    __lightdashTimestampDomains: {
-        myDatabase: {
-            mySchema: {
-                myTable: {
-                    MYTIMESTAMPCOLUMN: string;
-                };
-            };
-        };
-    };
-};
-export declare const expectedFields: Record<string, AnyType>;
-export declare const expectedRow: Record<string, AnyType>;
-export {};
-//# sourceMappingURL=SnowflakeWarehouseClient.mock.d.ts.map

package/dist/warehouseClients/SnowflakeWarehouseClient.mock.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"SnowflakeWarehouseClient.mock.d.ts","sourceRoot":"","sources":["../../src/warehouseClients/SnowflakeWarehouseClient.mock.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,OAAO,EACP,0BAA0B,EAC1B,aAAa,EAEhB,MAAM,mBAAmB,CAAC;AAI3B,eAAO,MAAM,WAAW,EAAE,0BASzB,CAAC;AASF,eAAO,MAAM,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAiG5C,CAAC;AAEF,cAAM,UAAU;IACZ,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAS;IAE9B,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAS;IAE9B,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAS;IAE/B,YAAY,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,GAAE,MAAU,EAIxD;IAED,OAAO,WAEN;IAED,OAAO,WAEN;IAED,QAAQ,WAEP;CACJ;AAED,eAAO,MAAM,gBAAgB,cAQ5B,CAAC;AAEF,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;QAgB5B,UAAU;YACN,QAAQ;gBAAI,OAAO;oBAAI,iBAAiB;;;;;CAGnD,CAAC;AAEF,eAAO,MAAM,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAQlD,CAAC;AAEF,eAAO,MAAM,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAQ/C,CAAC"}