Skip to content

feat(table-schema-check): added feature for filtering multiple tableSchema #133

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open
wants to merge 4 commits into
base: main
Choose a base branch
from
+879 −22
Open

feat(table-schema-check): added feature for filtering multiple tableSchema #133

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
4 commits
Select commit Hold shift + click to select a range
8d73ce0
if measure is * select all the tables in joinPath
Feb 16, 2025
f7eb71f
getusedtable schema corrected
Feb 19, 2025
bc9ef81
made tableschema handling in another variable
Feb 21, 2025
0f04bf4
package version updated
Feb 21, 2025
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
2 changes: 1 addition & 1 deletion meerkat-browser/package.json
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,6 +1,6 @@
{
"name": "@devrev/meerkat-browser",
"version": "0.0.90",
"version": "0.0.91",
"dependencies": {
"@swc/helpers": "~0.5.0",
"@devrev/meerkat-core": "*",
Expand Down
2 changes: 1 addition & 1 deletion meerkat-core/package.json
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,6 +1,6 @@
{
"name": "@devrev/meerkat-core",
"version": "0.0.90",
"version": "0.0.91",
"dependencies": {
"@swc/helpers": "~0.5.0"
},
Expand Down
355 changes: 355 additions & 0 deletions meerkat-core/src/get-used-table-schema/get-used-table-schema.spec.ts
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,355 @@
import { Query, TableSchema } from '../types/cube-types';
import { getUsedTableSchema } from './get-used-table-schema';

describe('getUsedTableSchema', () => {
const sampleTableSchema: TableSchema[] = [
{
name: 'table1',
sql: 'SELECT * FROM table1',
measures: [
{
name: 'measure1',
sql: 'SUM(value1)',
type: 'string',
},
],
dimensions: [
{
name: 'dimension1',
sql: 'dim1',
type: 'string',
},
],
joins: [],
},
{
name: 'table2',
sql: 'SELECT * FROM table2',
measures: [
{
name: 'measure2',
sql: 'COUNT(*)',
type: 'string',
},
],
dimensions: [
{
name: 'dimension2',
sql: 'dim2',
type: 'string',
},
],
joins: [],
},
{
name: 'table3',
sql: 'SELECT * FROM table3',
measures: [
{
name: 'measure3',
sql: 'AVG(value3)',
type: 'string',
},
],
dimensions: [
{
name: 'dimension3',
sql: 'dim3',
type: 'string',
},
],
joins: [],
},
{
name: 'table4',
sql: 'SELECT * FROM table4',
measures: [
{
name: 'measure4',
sql: 'SUM(value4)',
type: 'string',
},
],
dimensions: [
{
name: 'dimension1',
sql: 'dim4',
type: 'string',
},
],
joins: [],
},
{
name: 'table5',
sql: 'SELECT * FROM table5',
measures: [
{
name: 'measure5',
sql: 'COUNT(*)',
type: 'string',
},
],
dimensions: [
{
name: 'dimension2',
sql: 'dim5',
type: 'string',
},
],
joins: [],
},
];

it('should filter tables based on simple filter', () => {
const query: Query = {
filters: [
{
member: 'table1.measure1',
operator: 'equals',
values: ['100'],
},
],
measures: [],
};
const result = getUsedTableSchema(sampleTableSchema, query);
expect(result).toHaveLength(1);
expect(result[0].name).toBe('table1');
});

it('should filter tables based on AND conditions', () => {
const query: Query = {
filters: [
{
and: [
{
member: 'table1.measure1',
operator: 'equals',
values: ['100'],
},
{
member: 'table2.dimension2',
operator: 'equals',
values: ['value'],
},
],
},
],
measures: [],
};
const result = getUsedTableSchema(sampleTableSchema, query);
expect(result).toHaveLength(2);
expect(result.map((schema) => schema.name).sort()).toEqual([
'table1',
'table2',
]);
});

it('should filter tables based on OR conditions', () => {
const query: Query = {
filters: [
{
or: [
{
member: 'table1.measure1',
operator: 'equals',
values: ['100'],
},
{
member: 'table3.dimension3',
operator: 'equals',
values: ['value'],
},
],
},
],
measures: [],
};
const result = getUsedTableSchema(sampleTableSchema, query);
expect(result).toHaveLength(2);
expect(result.map((schema) => schema.name).sort()).toEqual([
'table1',
'table3',
]);
});

it('should handle nested AND-OR conditions', () => {
const query: Query = {
filters: [
{
and: [
{
member: 'table1.measure1',
operator: 'equals',
values: ['100'],
},
{
or: [
{
member: 'table2.dimension2',
operator: 'equals',
values: ['value1'],
},
{
member: 'table3.dimension3',
operator: 'equals',
values: ['value2'],
},
],
},
],
},
],
measures: [],
};
const result = getUsedTableSchema(sampleTableSchema, query);
expect(result).toHaveLength(3);
expect(result.map((schema) => schema.name).sort()).toEqual([
'table1',
'table2',
'table3',
]);
});

it('should handle multiple top-level filters', () => {
const query: Query = {
filters: [
{
member: 'table1.measure1',
operator: 'equals',
values: ['100'],
},
{
member: 'table2.measure2',
operator: 'equals',
values: ['200'],
},
],
measures: [],
};
const result = getUsedTableSchema(sampleTableSchema, query);
expect(result).toHaveLength(2);
expect(result.map((schema) => schema.name).sort()).toEqual([
'table1',
'table2',
]);
});

it('should handle complex nested filters', () => {
const query: Query = {
filters: [
{
and: [
{
or: [
{
member: 'table1.measure1',
operator: 'equals',
values: ['100'],
},
{
member: 'table2.measure2',
operator: 'equals',
values: ['200'],
},
],
},
{
member: 'table3.measure3',
operator: 'equals',
values: ['300'],
},
],
},
],
measures: [],
};
const result = getUsedTableSchema(sampleTableSchema, query);
expect(result).toHaveLength(3);
expect(result.map((schema) => schema.name).sort()).toEqual([
'table1',
'table2',
'table3',
]);
});

it('should filter tables based on measures', () => {
const query: Query = {
measures: ['table1.measure1', 'table2.measure2'],
};
const result = getUsedTableSchema(sampleTableSchema, query);
expect(result).toHaveLength(2);
expect(result.map((schema) => schema.name).sort()).toEqual([
'table1',
'table2',
]);
});

it('should filter tables based on dimensions', () => {
const query: Query = {
measures: [],
dimensions: ['table1.dimension1', 'table3.dimension3'],
};
const result = getUsedTableSchema(sampleTableSchema, query);
expect(result).toHaveLength(2);
expect(result.map((schema) => schema.name).sort()).toEqual([
'table1',
'table3',
]);
});

it('should filter tables based on order', () => {
const query: Query = {
measures: [],
order: {
'table1.dimension1': 'asc',
'table2.dimension2': 'desc',
},
};
const result = getUsedTableSchema(sampleTableSchema, query);
expect(result).toHaveLength(2);
expect(result.map((schema) => schema.name).sort()).toEqual([
'table1',
'table2',
]);
});

it('should filter tables based on joinPaths', () => {
const query: Query = {
measures: [],
joinPaths: [
[
{ left: 'table1.dimension1', right: 'table2.dimension2', on: 'id' },
{ left: 'table2.dimension2', right: 'table3.dimension3', on: 'id' },
],
],
};
const result = getUsedTableSchema(sampleTableSchema, query);
expect(result).toHaveLength(3);
expect(result.map((schema) => schema.name).sort()).toEqual([
'table1',
'table2',
'table3',
]);
});
it('should filter tables based on a combination of measures, dimensions, order, and unique joinPaths', () => {
const query: Query = {
measures: ['table1.measure1'],
dimensions: ['table2.dimension2'],
order: {
'table3.dimension3': 'asc',
},
joinPaths: [
[{ left: 'table4.dimension1', right: 'table5.dimension2', on: 'id' }],
],
};
const result = getUsedTableSchema(sampleTableSchema, query);
expect(result).toHaveLength(5);
expect(result.map((schema) => schema.name).sort()).toEqual([
'table1',
'table2',
'table3',
'table4',
'table5',
]);
});
});
Loading
Loading