AI-optimized language for querying structured data, knowledge graphs, and retrieval-augmented generation pipelines. The Python script below is designed to teach Memelang to your LLM.
✓ Copy all code to paste into your AI.
'''
info@memelang.net | (c)2025 HOLTWORK LLC | Patents Pending
This script translates Memelang to SQL
1. MEMELANG USES AXES, LIMIT_AXIS HIGH -> LOW
| AXIS | SQL ANALOG | RDF ANALOG |
| ---: | ----------- | ----------- |
| 3 | Table | Graph |
| 2 | Primary Key | Subject |
| 1 | Column | Predicate |
| 0 | Value | Object |
2. EXAMPLE QUERY
MEMELANG: movies * actor "Mark Hamill",Mark ; movie * ; rating >4 ;;
SQL SIMPLE: SELECT actor, movie, rating FROM movies WHERE actor IN ('Mark Hamill', 'Mark') AND rating > 4
SQL LITERAL: SELECT CONCAT_WS(' ', 'movies', t0.id, 'actor', t0.actor, ';', 'movie', t0.movie, ';', 'rating', t0.rating, ';;') AS meme FROM movies AS t0 WHERE t0.actor IN ('Mark Hamill', 'Mark') AND t0.rating > 4
3. VARIABLE EXAMPLE ACTOR NAME = MOVIE TITLE
MEMELANG: movies * actor $x=* ; movie $x ;;
SQL SIMPLE: SELECT id, actor, movie FROM movies WHERE actor=movie
SQL LITERAL: SELECT CONCAT_WS(' ', 'movies', t0.id, 'actor', t0.actor, ';', 'movie', t0.movie, ';;') AS meme FROM movies AS t0 WHERE t0.actor=t0.movie
4. EXAMPLE JOIN
MEMELANG: movies * actor "Mark Hamill" ; movie * ; !@ @ @ ; actor * ;;
MEMELANG ALT: movies $id=* actor "Mark Hamill" ; movie * ; !$id @ @ ; actor !"Mark Hamill" ;;
SQL SIMPLE: SELECT t0.actor, t0.movie, t1.movie, t1.actor FROM movies AS t0, movies AS t1 WHERE t0.actor = 'Mark Hamill' AND t1.id != t0.id AND t1.movie = t0.movie
SQL LITERAL: SELECT CONCAT_WS(' ', 'movies', t0.id, 'actor', t0.actor, ';', 'movie', t0.movie, ';', t1.id, 'movie', t1.movie, ';', 'actor', t1.actor, ';;' ) AS meme FROM movies AS t0, movies AS t1 WHERE t0.actor = 'Mark Hamill' AND t1.id != t0.id AND t1.movie = t0.movie
5. EXAMPLE TABLE JOIN WITH VARIABLE, ACTOR NAME = MOVIE TITLE
MEMELANG: actors * age >21; name $n=* ; movies * title $n ;;
MEMELANG ALT: actors * age >21; name * ; movies * title @ ;;
SQL SIMPLE: SELECT t0.name, t0.age, t1.title FROM actors AS t0, movies AS t1 WHERE t0.age > 21 AND t1.title = t0.name;
SQL LITERAL: SELECT CONCAT_WS(' ', 'actors', t0.id, 'age', t0.age, ';', 'name', t0.name, ';', 'movies', t1.id, 'title', t1.title, ';;' ) AS meme FROM actors AS t0, movies AS t1 WHERE t0.age > 21 AND t1.title = t0.name
'''
MEMELANG_VER = 8.22
import random, re, json, operator
from typing import List, Iterator, Iterable, Dict, Tuple, Any, Union
Axis, Memelang = int, str
SIGIL, WILD, MSAME, VSAME, EMPTY, EOF = '$', '*', '^', '@', '_', None
SEP_LIMIT, SEP_DATA, SEP_VCTR, SEP_MTRX = ' ', ',', ';', ';;'
SEP_VCTR_PRETTY, SEP_MTRX_PRETTY = ' ; ', ' ;;\n'
ELIDE_VSAME = True
TOKEN_KIND_PATTERNS = (
('COMMENT', r'//[^\n]*'),
('QUOTE', r'"(?:[^"\\]|\\.)*"'), # ALWAYS JSON QUOTE ESCAPE EXOTIC CHARS "John \"Jack\" Kennedy"
('META', r"'[^']*'"),
('IGNORE', r'-*\|'),
('SEP_MTRX', re.escape(SEP_MTRX)),
('SEP_VCTR', re.escape(SEP_VCTR)),
('SEP_LIMIT', r'\s+'),
('SEP_DATA', re.escape(SEP_DATA)),
('GE', r'>='),
('LE', r'<='),
('NOT', r'!=?'),
('EQL', r'='),
('GT', r'>'),
('LT', r'<'),
('WILD', re.escape(WILD)), # WILDCARD, MATCHES WHOLE VALUE, NEVER QUOTE
('MSAME', re.escape(MSAME)), # REFERENCES (MTRX_AXIS-1, VCTR_AXIS=-1, LIMIT_AXIS)
('VSAME', re.escape(VSAME)), # REFERENCES (MTRX_AXIS, VCTR_AXIS-1, LIMIT_AXIS)
('EMPTY', re.escape(EMPTY)), # EMPTY SET, ANTI-WILD
('VAR', r'\$[A-Za-z0-9]+'),
('ALNUM', r'[A-Za-z][A-Za-z0-9]*'), # ALPHANUMERICS ARE UNQUOTED
('FLOAT', r'-?\d*\.\d+'),
('INT', r'-?\d+'),
('MISMATCH', r'.'),
)
MASTER_PATTERN = re.compile('|'.join(f'(?P<{kind}>{pat})' for kind, pat in TOKEN_KIND_PATTERNS))
OPR_DICT = {'EQL': operator.eq, 'NOT': operator.ne, 'GT': operator.gt, 'GE': operator.ge, 'LT': operator.lt, 'LE': operator.le}
OPR_DATA_KINDS = {'EQL','NOT'}
SEP_KINDS = {'SEP_MTRX','SEP_VCTR','SEP_LIMIT','SEP_DATA',EOF}
DATA_KINDS = {'ALNUM', 'QUOTE', 'INT', 'FLOAT', 'VAR', 'VSAME', 'MSAME', 'EMPTY','WILD'}
UNITARY_KINDS = {'ALNUM', 'QUOTE', 'INT', 'FLOAT', 'VSAME', 'MSAME', 'EQL', 'DATUM', 'NOVAR'}
EBNF = '''
LIMIT ::= ([[VAR] OPR] DATUM {SEP_DATA DATUM}) | OPR
VCTR ::= LIMIT {SEP_LIMIT LIMIT}
MTRX ::= VCTR {SEP_VCTR VCTR}
MEME ::= MTRX {SEP_MTRX MTRX}
'''
class Token():
kind: str
lexeme: str
datum: Union[str, float, int]
def __init__(self, kind: str, lexeme: str):
self.kind = kind
self.lexeme = lexeme
if kind == 'QUOTE': self.datum = json.loads(lexeme)
elif kind == 'FLOAT': self.datum = float(lexeme)
elif kind == 'INT': self.datum = int(lexeme)
else: self.datum = lexeme
@property
def unitary(self) -> bool: return self.kind in UNITARY_KINDS
def dump(self) -> str|float|int: return self.datum
def __str__(self) -> Memelang: return self.lexeme
TOK_EQL = Token('EQL', '') # ELIDED '='
TOK_DATUM = Token('DATUM', '') # ELIDED
TOK_NOVAR = Token('NOVAR', '') # ELIDED
TOK_NOT = Token('NOT', '!')
TOK_GT = Token('GT', '>')
TOK_SEP_DATA = Token('SEP_DATA', SEP_DATA)
TOK_SEP_LIMIT = Token('SEP_LIMIT', SEP_LIMIT)
TOK_SEP_VCTR = Token('SEP_VCTR', SEP_VCTR)
TOK_SEP_MTRX = Token('SEP_MTRX', SEP_MTRX)
class Stream:
def __init__(self, token: Iterable[Token]):
self.token: Iterator[Token] = iter(token)
self.buffer: List[Token] = []
def peek(self, fwd: int = 1) -> Union[str, None]:
while(len(self.buffer)<fwd):
val = next(self.token, EOF)
if val is EOF: return EOF
self.buffer.append(val)
return self.buffer[fwd-1].kind
def next(self) -> Token:
if not self.buffer:
val = next(self.token, EOF)
if val is EOF: raise SyntaxError('E_EOF')
self.buffer.append(val)
return self.buffer.pop(0)
class Node(list):
opr: Token = TOK_EQL
def __init__(self, *items: Union['Node', Token], opr:Token|None = None):
super().__init__(items)
if opr is not None: self.opr = opr
def prepend(self, item):
self.insert(0, item)
def pad(self, padding:Union['Node', Token]) -> None:
max_len = len(self[0])
for idx, item in enumerate(self):
diff = max_len - len(item)
if diff>0: self[idx] += [padding] * diff
elif diff<0: raise SyntaxError('E_PAD') # FIRST MUST BE LONGEST
@property
def unitary(self) -> bool: return self.opr.unitary and all(item.unitary for item in self)
def dump(self) -> List: return [self.opr.dump(), [item.dump() for item in self]]
def check(self) -> 'Node':
if len(self)==0: raise SyntaxError('E_NO_LIST')
return self
def __str__(self) -> Memelang: return self.opr.lexeme.join(map(str, self))
class Data(Node):
opr: Token = TOK_DATUM
DATA_MSAME = Data(Token('MSAME', MSAME))
DATA_VSAME = Data(Token('VSAME', VSAME))
DATA_EMPTY = Data(Token('EMPTY', EMPTY))
class Limit(Node):
opr: Token = TOK_EQL # ELIDED '='
@property
def k1(self) -> str: return self[1][0].kind
def check(self) -> 'Limit':
if len(self)!=2: raise SyntaxError('E_NO_LIST')
if any(t.kind=='WILD' for t in self[1]):
if self.opr.kind == 'EQL': self.opr=TOK_NOT
elif self.opr.kind == 'NOT': self.opr=TOK_EQL
else: self.opr = TOK_GT # WILD MATCHES ANY NUMERIC
self[1]=DATA_EMPTY
return self
LIMIT_EQL_VSAME = Limit(TOK_NOVAR, DATA_VSAME, opr=TOK_EQL)
class Vector(Node):
opr: Token = TOK_SEP_LIMIT
class Matrix(Node):
opr: Token = TOK_SEP_VCTR
def lex(src: Memelang) -> Iterator[Token]:
for m in MASTER_PATTERN.finditer(src):
kind = m.lastgroup
if kind in {'COMMENT','META','IGNORE'}: continue
if kind == 'MISMATCH': raise SyntaxError('E_TOK')
yield Token(kind, m.group())
def parse(src: Memelang) -> Iterator[Matrix]:
tokens = Stream(lex(src))
bound_vars = []
mtrx = Matrix()
vctr = Vector()
limit = Limit()
while tokens.peek():
# LIMIT: Single axis constraint
# [VAR]
data = None
var = TOK_NOVAR
if tokens.peek() == 'VAR':
if tokens.peek(2) in OPR_DICT:
var = tokens.next()
bound_vars.append(var.lexeme)
elif tokens.peek(2) not in SEP_KINDS: raise SyntaxError('E_VAR_NXT')
# [OPR]
if tokens.peek() in OPR_DICT:
limit.opr=tokens.next()
if tokens.peek() not in DATA_KINDS:
if ELIDE_VSAME: data = Data(Token('VSAME', ''))
else: raise SyntaxError('E_NEVER_SPACE_AFTER_OPR')
# DATUM {SEP_DATA DATUM}
if tokens.peek() in DATA_KINDS:
data=Data()
data.append(tokens.next())
while tokens.peek()=='SEP_DATA':
data.opr = tokens.next()
if tokens.peek()=='SEP_LIMIT': raise SyntaxError('E_NEVER_SPACE_AFTER_COMMA')
if tokens.peek() not in DATA_KINDS: raise SyntaxError('E_DATA_KIND')
data.append(tokens.next())
if data:
# LOGIC CHECKS
if any(t.kind == 'VAR' and t.lexeme not in bound_vars for t in data): raise SyntaxError('E_VAR_UNBOUND')
if len(mtrx)==0 and any(t.kind == 'VSAME' for t in data): raise SyntaxError('E_VSAME_OOB')
if len(data)>1 and limit.opr.kind not in OPR_DATA_KINDS: raise SyntaxError('E_DATA_OPR')
# FINALIZE LIMIT
limit.append(var)
limit.append(data)
vctr.prepend(limit.check()) # LIMIT_AXIS: HIGH -> LOW
limit=Limit()
continue
# VCTR: Conjunctive vector of axis constraints
if tokens.peek() == 'SEP_VCTR':
if vctr: mtrx.append(vctr.check())
vctr = Vector()
tokens.next()
continue
# MTRX: Conjunctive matrix of axis constraints
if tokens.peek() == 'SEP_MTRX':
if vctr: mtrx.append(vctr.check())
if mtrx: yield mtrx.check()
vctr = Vector()
mtrx = Matrix()
tokens.next()
continue
if tokens.peek() == 'SEP_LIMIT':
tokens.next()
continue
raise SyntaxError('E_TOK')
if vctr: mtrx.append(vctr.check())
if mtrx: yield mtrx.check()
class Meme(Node):
opr: Token = TOK_SEP_MTRX
results: List[List[List[Data]]]
bindings: Dict[str, Tuple[Axis, Axis, Axis]]
src: Memelang
def __init__(self, src: Memelang):
self.src = src
self.bindings = {}
super().__init__(*parse(src))
self.check()
def check(self) -> 'Meme':
for mtrx_axis, mtrx in enumerate(self):
if not isinstance(mtrx, Matrix): raise TypeError('E_TYPE_VCTR')
for vctr_axis, vctr in enumerate(mtrx):
if not isinstance(vctr, Vector): raise TypeError('E_TYPE_VCTR')
for limit_axis, limit in enumerate(vctr):
if not isinstance(limit, Limit): raise TypeError('E_TYPE_LIMIT')
if limit[0].kind=='VAR': self.bindings[limit[0].lexeme] = (mtrx_axis, vctr_axis, limit_axis)
self[mtrx_axis].pad(LIMIT_EQL_VSAME)
self.results = [[[[] for limit in vctr] for vctr in mtrx] for mtrx in self]
return self
def expand(self, data: Data, from_limit_axis: Axis, from_vctr_axis: Axis, from_mtrx_axis: Axis) -> Data:
expansion=Data()
coords: Tuple[Axis, Axis, Axis] = ()
for tok in data:
coords = ()
if tok.kind == 'VSAME': coords = (from_mtrx_axis, from_vctr_axis-1, from_limit_axis)
elif tok.kind == 'MSAME': coords = (from_mtrx_axis-1, -1, from_limit_axis)
elif tok.kind == 'VAR': coords = self.bindings[tok.lexeme]
expansion.extend(self.results[coords[0]][coords[1]][coords[2]] if coords else [tok])
if len(expansion)>1: expansion.opr = TOK_SEP_DATA
return expansion.check()
def store(self):
for mtrx_axis, mtrx in enumerate(self):
for vctr_axis, vctr in enumerate(mtrx):
for limit_axis, limit in enumerate(vctr):
if not limit.unitary: raise SyntaxError('E_LIMIT_UNIT')
self.results[mtrx_axis][vctr_axis][limit_axis]=self.expand(limit[1], limit_axis, vctr_axis, mtrx_axis)
def intersect(query: Limit, store: Data) -> Data:
if not store: store=DATA_EMPTY
opr_kind, intersection, query_data = query.opr.kind, Data(), [t.datum for t in query[1]]
if opr_kind == 'EQL': intersection.extend([t for t in store if t.datum in query_data])
elif opr_kind == 'NOT': intersection.extend([t for t in store if t.datum not in query_data])
# RETURN ANY NUMERIC FOR GT EMPTY
elif EMPTY in query_data: intersection.extend([t for t in store if t.kind in {'INT','FLOAT'}])
elif len(query_data)!=1 or not isinstance(query_data[0], (int,float)): raise TypeError('E_INTER_NUM')
intersection.extend([t for t in store if t.kind in {'INT','FLOAT'} and OPR_DICT[opr_kind](t.datum, query_data[0])])
return intersection
# GENERATE RANDOM MEMELANG DATA
class Fuzz():
@staticmethod
def datum(kind:str, i:int=1) -> Memelang:
if kind=='ALNUM': return ''.join(random.choice('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ') for _ in range(i))
if kind=='QUOTE': return json.dumps(''.join(random.choice(' -_+,./<>[]{}\'"!@#$%^&*()abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ') for _ in range(i)))
if kind=='INT': return str(random.randint(-i, i))
if kind=='FLOAT': return str(random.uniform(-i, i))
if kind=='VAR': return SIGIL + Fuzz.datum('ALNUM', i)
@staticmethod
def limit(bindings: List[str]|None = None) -> Memelang:
if not bindings: bindings = []
var = ''
do_assign_variable = random.randint(0, 1)
if do_assign_variable: var += Fuzz.datum('VAR',3)
opr = random.choice(['=','!=','>','<','<=','>='])
data: str = ''
if opr in {'=','!'}:
data_list_len = random.randint(1, 5)
data_list: List[Any] = []
for _ in range(data_list_len):
datum_type = random.randint(1, 10)
if datum_type == 1: data_list.append(Fuzz.datum('QUOTE',10))
elif datum_type == 2: data_list.append(Fuzz.datum('INT', 100))
elif datum_type == 3: data_list.append(Fuzz.datum('FLOAT', 100))
elif datum_type == 4 and bindings: data_list.append(random.choice(bindings))
elif datum_type == 5 and VSAME in bindings: data_list.append(VSAME)
else: data_list.append(Fuzz.datum('ALNUM', 5))
data += SEP_DATA.join(data_list)
else:
data = Fuzz.datum('FLOAT', 100)
if var:
assert opr
bindings.append(var)
return var + opr + data
@staticmethod
def vector(limit_len:int = 4) -> Memelang:
bindings, vector = [], []
for i in range(limit_len):
if i>0: bindings.append(VSAME)
vector.append(Fuzz.limit(bindings))
return SEP_LIMIT.join(vector) + SEP_VCTR_PRETTY
@staticmethod
def mtrx_table(col_len:int = 5) -> Memelang:
return Fuzz.datum('ALNUM',5) + SEP_LIMIT + WILD + SEP_LIMIT + SEP_VCTR_PRETTY.join(Fuzz.datum('ALNUM',5) + Fuzz.limit() for _ in range(col_len)) + SEP_MTRX_PRETTY
### SQL ###
SQL = str
Param = int|float|str
class SQLUtil():
@staticmethod
def escape(token: Token, bindings: dict) -> SQL:
if token.kind in {'VAR', 'VSAME'}:
if token.lexeme not in bindings: raise SyntaxError('E_VAR_BIND')
return SQLUtil.escape(bindings[token.lexeme], bindings)
elif token.kind in {'DBCOL'}: return token.datum
return '%s'
@staticmethod
def escape2(token: Token, bindings: dict) -> None|Param:
if token.kind in {'VAR', 'VSAME'}:
if token.lexeme not in bindings: raise SyntaxError('E_VAR_BIND')
return SQLUtil.escape2(bindings[token.lexeme], bindings)
elif token.kind in {'DBCOL'}: return None
return token.datum
@staticmethod
def compare(alias_col: str, limit: Limit, bindings: dict) -> Tuple[SQL, List[None|Param]]:
if len(limit[1]) > 1:
if limit.opr.kind == 'EQL': sym = 'IN'
elif limit.opr.kind == 'NOT': sym = 'NOT IN'
else: raise SyntaxError()
return f'{alias_col} {sym} ('+ ', '.join(SQLUtil.escape(v, bindings) for v in limit[1]) + ')', [SQLUtil.escape2(v, bindings) for v in limit[1]]
sym = {'EQL':'=','NOT':'!=','GT':'>','GE':'>=','LT':'<','LE':'<='}[limit.opr.kind]
return f'{alias_col} {sym} {SQLUtil.escape(limit[1][0], bindings)}', [SQLUtil.escape2(limit[1][0], bindings)]
class MemeSQL(Meme):
@classmethod
def from_output(self, sql_output: str) -> 'MemeSQL':
lines=[l for l in sql_output.splitlines() if l.startswith('|')]
if not lines:return ''
header=[c.strip() for c in lines[0].strip('|').split('|')]
mtrxs=[]
for line in lines[1:]:
cells=[c.strip() for c in line.strip('|').split('|')]
if len(cells)!=len(header):continue
id_val=cells[0]
parts=[f'{header[i]} {cells[i]}' for i in range(1,len(header))]
mtrxs.append(f'$id={id_val} ' + SEP_VCTR_PRETTY.join(parts))
return self(SEP_MTRX_PRETTY.join(mtrxs) + SEP_MTRX_PRETTY)
@classmethod
def from_insert(self, sql_insert: SQL) -> 'MemeSQL':
m = re.search(r'INSERT\s+INTO\s+(\w+)\s*\((.*?)\)\s*VALUES\s*(.*);', sql_insert, re.I | re.S)
if not m: return ''
table = m.group(1)
header = [h.strip() for h in m.group(2).split(',')]
rows_sql = re.findall(r'\(([^()]*)\)', m.group(3))
mtrxs = []
for idx, row in enumerate(rows_sql):
cells = [c.strip(" '\"") for c in re.findall(r"'[^']*'|[^,]+", row)]
if len(cells) != len(header): continue
id = cells[0]
col_tokens = header[1:] if idx == 0 else [MSAME] * (len(header) - 1)
parts = [f'{col_tokens[i]} {cells[i + 1]}' for i in range(len(col_tokens))]
mtrxs.append(f'{table} $id={id} ' + SEP_VCTR_PRETTY.join(parts))
return self(SEP_MTRX_PRETTY.join(mtrxs) + SEP_MTRX_PRETTY)
class MemeSQLTable(MemeSQL):
primary: str = 'id'
tbl: Axis = 3
row: Axis = 2
col: Axis = 1
val: Axis = 0
def to_select(self) -> Tuple[SQL, List[Param]]:
alias_idx: int = 0
statements: List[SQL] = []
params: List[Param] = []
alias = -1
for mtrx in self:
froms, wheres, selects, sqlbind = [], [], [], {}
prev = {alias:None, self.tbl:None, self.row:None, self.col:None, self.val:None}
for vctr in mtrx:
curr = {alias:prev[alias], self.tbl:None, self.row:None, self.col:None, self.val:None}
for axis in (self.tbl, self.row, self.col, self.val):
if vctr[axis].opr.kind == 'EQL' and vctr[axis].k1 == 'VSAME': curr[axis] = prev[axis]
elif vctr[axis].unitary: curr[axis] = vctr[axis][1][0]
elif axis in (self.row, self.val): curr[axis] = None
else: raise SyntaxError(f'E_SQL_SUPPORT_V{axis}')
# JOIN
if prev[alias] is None or any(curr[axis] is None or prev[axis] != curr[axis] for axis in (self.tbl, self.row)):
# TABLE ALIAS
curr[alias] = f't{alias_idx}'
froms.append(f'{curr[self.tbl]} AS {curr[alias]}')
alias_idx += 1
# PRIMARY KEY
if curr[self.row] is None: curr[self.row]=Token('DBCOL', f'{curr[alias]}.{self.primary}')
if prev[self.row] is not None: sqlbind[VSAME]=prev[self.row]
if vctr[self.row].k1 != 'EMPTY':
w, ps = SQLUtil.compare(f'{curr[alias]}.{self.primary}', vctr[self.row], sqlbind)
wheres.append(w)
params.extend([p for p in ps if p is not None])
if prev[self.tbl] != curr[self.tbl]: selects.append(f"'{curr[self.tbl]}'")
selects.append(f'{curr[alias]}.{self.primary}')
# COLUMN = VALUE
ccol = curr[self.col].datum
cacol = f'{curr[alias]}.{ccol}'
if curr[self.val] is None: curr[self.val]=Token('DBCOL', cacol)
if prev[self.val] is not None: sqlbind[VSAME]=prev[self.val]
if vctr[self.val].k1 != 'EMPTY':
w, ps = SQLUtil.compare(cacol, vctr[self.val], sqlbind)
wheres.append(w)
params.extend([p for p in ps if p is not None])
selects.extend([f"'{ccol}'", cacol, f"'{SEP_VCTR}'"])
# BIND VARS
for axis in (self.row, self.val):
if vctr[axis][0].kind == 'VAR': sqlbind[vctr[axis][0].lexeme]=curr[axis]
prev = curr.copy()
if not wheres: raise SyntaxError('E_EMPTY_WHERE')
selects.append(f"'{SEP_MTRX}'")
statements.append(f'SELECT CONCAT_WS(\'{SEP_LIMIT}\', ' + ', '.join(selects) + ') AS meme FROM ' + ', '.join(froms) + ' WHERE ' + ' AND '.join(wheres))
return ' UNION '.join(statements) + ';', params
class MemeSQLTuple(MemeSQL):
tbl: str = 'vtbl'
val: Axis|None = 0
row: Axis = 2
def sql_create_table(self) -> SQL:
return f'CREATE TABLE IF NOT EXISTS {self.tbl} (a3 TEXT, a2 BIGINT, a1 TEXT, a0s TEXT, a0id BIGINT, a0f DOUBLE PRECISION);'
def to_select(self) -> Tuple[SQL, List[Param]]:
src = -1
alias_idx: int = 0
statements: List[SQL] = []
params: List[Param] = []
for mtrx in self:
froms, wheres, selects, groupbys, sqlbind = [], [], [], [], {}
vlen = len(mtrx[0])
prev = [None] * (vlen + 1)
for vctr in mtrx:
curr = [None] * vlen
curr.append(f'v{alias_idx}')
froms.append(f'{self.tbl} AS {curr[src]}')
for axis in range(vlen-1, -1, -1):
if axis != self.val:
sel_col = f'{curr[src]}.a{axis}'
whr_col = f'{curr[src]}.a{axis}'
else:
axf, axs = f'{curr[src]}.a{axis}f', f'{curr[src]}.a{axis}s'
sel_col = f'(CASE WHEN {axf} IS NOT NULL THEN {axf}::text ELSE \'"\' || {axs} || \'"\' END)'
whr_col = axf if vctr[axis].opr.kind in {'GT','LT','GE','LE'} or vctr[axis].k1 in {'INT','FLOAT'} else axs
selects.append(sel_col)
if (vctr[axis].opr.kind, vctr[axis].k1) == ('EQL', 'VSAME'): curr[axis] = prev[axis]
elif vctr[axis].unitary: curr[axis] = vctr[axis][1][0]
else: curr[axis] = Token('DBCOL', whr_col)
if prev[axis] is not None: sqlbind[VSAME]=prev[axis]
if vctr[axis].k1 != 'EMPTY':
w, ps = SQLUtil.compare(whr_col, vctr[axis], sqlbind)
wheres.append(w)
params.extend([p for p in ps if p is not None])
if vctr[axis][0].kind == 'VAR': sqlbind[vctr[axis][0].lexeme]=curr[axis]
if prev[src] is None or any(prev[axis] != curr[axis] for axis in range(vlen-1, self.row-1, -1)):
for a in range(vlen-1, self.row-1, -1): groupbys.append(f"{curr[src]}.a{a}")
selects.append(f"'{SEP_VCTR}'")
prev = curr[:]
alias_idx += 1
selects.append(f"'{SEP_MTRX}'")
groupbystr = ' GROUP BY ' + ', '.join(groupbys) if groupbys else ''
statements.append(f'SELECT CONCAT_WS(\'{SEP_LIMIT}\', ' + ', '.join(selects) + ') AS meme FROM ' + ', '.join(froms) + ' WHERE ' + ' AND '.join(wheres) + groupbystr)
return ' UNION '.join(statements) + ';', params
### MAIN ###
if __name__ == '__main__':
memelangs: List[Memelang] = [
'movies * actor "Mark Hamill",Mark ; movie * ; rating >4 ;;',
'movies * actor "Mark Hamill" ; movie * ; !@ @ @ ; actor * ;;',
'movies $id=* actor "Mark Hamill" ; movie * ; !$id @ @ ; actor !"Mark Hamill" ;;',
'actors * age >21; name $n=* ; movies * title $n ;;',
'actors * age >21; name * ; movies * title @ ;;'
]
if ELIDE_VSAME: memelangs.append('movies * actor "Mark Hamill",Mark ; rating >4 ; movie * ; ! = = ; actor * ;;')
for src in memelangs: print(src, MemeSQLTable(src).to_select())
info@memelang.net · Patents Pending · ©2025 HOLTWORK LLC