mirror of
https://github.com/github/codeql.git
synced 2025-12-16 16:53:25 +01:00
90 lines
3.1 KiB
Python
Executable File
90 lines
3.1 KiB
Python
Executable File
#!/usr/bin/env python3
|
|
import pathlib
|
|
|
|
import inflection
|
|
|
|
from swift.codegen.lib import paths, schema, generator
|
|
from swift.codegen.lib.dbscheme import *
|
|
|
|
log = logging.getLogger(__name__)
|
|
|
|
|
|
def dbtype(typename):
|
|
""" translate a type to a dbscheme counterpart, using `@lower_underscore` format for classes """
|
|
if typename[0].isupper():
|
|
return "@" + inflection.underscore(typename)
|
|
return typename
|
|
|
|
|
|
def cls_to_dbscheme(cls: schema.Class):
|
|
""" Yield all dbscheme entities needed to model class `cls` """
|
|
if cls.derived:
|
|
yield Union(dbtype(cls.name), (dbtype(c) for c in cls.derived))
|
|
# output a table specific to a class only if it is a leaf class or it has 1-to-1 properties
|
|
# Leaf classes need a table to bind the `@` ids
|
|
# 1-to-1 properties are added to a class specific table
|
|
# in other cases, separate tables are used for the properties, and a class specific table is unneeded
|
|
if not cls.derived or any(f.is_single for f in cls.properties):
|
|
binding = not cls.derived
|
|
keyset = KeySet(["id"]) if cls.derived else None
|
|
yield Table(
|
|
keyset=keyset,
|
|
name=inflection.tableize(cls.name),
|
|
columns=[
|
|
Column("id", type=dbtype(cls.name), binding=binding),
|
|
] + [
|
|
Column(f.name, dbtype(f.type)) for f in cls.properties if f.is_single
|
|
]
|
|
)
|
|
# use property-specific tables for 1-to-many and 1-to-at-most-1 properties
|
|
for f in cls.properties:
|
|
if f.is_optional:
|
|
yield Table(
|
|
keyset=KeySet(["id"]),
|
|
name=inflection.tableize(f"{cls.name}_{f.name}"),
|
|
columns=[
|
|
Column("id", type=dbtype(cls.name)),
|
|
Column(f.name, dbtype(f.type)),
|
|
],
|
|
)
|
|
elif f.is_repeated:
|
|
yield Table(
|
|
keyset=KeySet(["id", "index"]),
|
|
name=inflection.tableize(f"{cls.name}_{f.name}"),
|
|
columns=[
|
|
Column("id", type=dbtype(cls.name)),
|
|
Column("index", type="int"),
|
|
Column(inflection.singularize(f.name), dbtype(f.type)),
|
|
]
|
|
)
|
|
|
|
|
|
def get_declarations(data: schema.Schema):
|
|
return [d for cls in data.classes for d in cls_to_dbscheme(cls)]
|
|
|
|
|
|
def get_includes(data: schema.Schema, include_dir: pathlib.Path):
|
|
includes = []
|
|
for inc in data.includes:
|
|
inc = include_dir / inc
|
|
with open(inc) as inclusion:
|
|
includes.append(SchemeInclude(src=inc.relative_to(paths.swift_dir), data=inclusion.read()))
|
|
return includes
|
|
|
|
|
|
def generate(opts, renderer):
|
|
input = opts.schema
|
|
out = opts.dbscheme
|
|
|
|
data = schema.load(input)
|
|
|
|
dbscheme = Scheme(src=input.relative_to(paths.swift_dir),
|
|
includes=get_includes(data, include_dir=input.parent),
|
|
declarations=get_declarations(data))
|
|
|
|
renderer.render(dbscheme, out)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
generator.run(generate, tags=["schema", "dbscheme"])
|