Python schema示例

示例#1

文件： test_smart_completion_multiple_schemata.py 项目： dbcli/pgcli

def test_set_schema(completer):
    text = ('SET SCHEMA ')
    result = get_result(completer, text)
    assert completions_to_set(result) == completions_to_set([
        schema(u"'blog'"),
        schema(u"'Custom'"),
        schema(u"'custom'"),
        schema(u"'public'")])

示例#2

def test_set_schema(completer):
    text = ('SET SCHEMA ')
    result = result_set(completer, text)
    assert result == set([
        schema(u"'blog'"),
        schema(u"'Custom'"),
        schema(u"'custom'"),
        schema(u"'public'")])

示例#3

def test_set_schema(completer):
    text = "SET SCHEMA "
    result = get_result(completer, text)
    assert completions_to_set(result) == completions_to_set([
        schema("'blog'"),
        schema("'Custom'"),
        schema("'custom'"),
        schema("'public'")
    ])

示例#4

文件： test_smart_completion_multiple_schemata.py 项目： avdd/pgcli

def test_table_casing(completer_with_casing, complete_event, text):
    result = completer_with_casing.get_completions(
        Document(text=text), complete_event)
    assert set(result) == set([
        schema('public'),
        schema('CUSTOM'),
        schema('"Custom"'),
        table('users'),
        table('Orders'),
        table('"select"'),
        function('Func1()'),
        function('func2()')])

示例#5

文件： test_smart_completion_multiple_schemata.py 项目： avdd/pgcli

def test_aliases_with_casing(completer_aliases_casing, complete_event, text):
    result = completer_aliases_casing.get_completions(
        Document(text=text), complete_event)
    assert set(result) == set([
        schema('public'),
        schema('CUSTOM'),
        schema('"Custom"'),
        table('users u'),
        table('Orders O' if text == 'SELECT * FROM ' else 'Orders O2'),
        table('"select" s'),
        function('Func1() F'),
        function('func2() f')])

示例#6

文件： test_smart_completion_multiple_schemata.py 项目： unixc3t/pgcli

def test_table_casing(completer_with_casing, complete_event, text):
    result = completer_with_casing.get_completions(Document(text=text),
                                                   complete_event)
    assert set(result) == set([
        schema('public'),
        schema('CUSTOM'),
        schema('"Custom"'),
        table('users'),
        table('Orders'),
        table('"select"'),
        function('Func1()'),
        function('func2()')
    ])

示例#7

文件： test_smart_completion_multiple_schemata.py 项目： unixc3t/pgcli

def test_aliases_with_casing(completer_aliases_casing, complete_event, text):
    result = completer_aliases_casing.get_completions(Document(text=text),
                                                      complete_event)
    assert set(result) == set([
        schema('public'),
        schema('CUSTOM'),
        schema('"Custom"'),
        table('users u'),
        table('Orders O' if text == 'SELECT * FROM ' else 'Orders O2'),
        table('"select" s'),
        function('Func1() F'),
        function('func2() f')
    ])

示例#8

文件： test_smart_completion_public_schema_only.py 项目： arthurli1126/pgcli

def test_cased_joins(completer, text):
    result = result_set(completer, text)
    assert result == set([schema('PUBLIC')] + cased_rels + [
        join('"Users" ON "Users".UserID = Users.ID'),
        join('Users Users2 ON Users2.ID = Users.PARENTID'),
        join('Users Users2 ON Users2.PARENTID = Users.ID'),
    ])

示例#9

文件： test_smart_completion_public_schema_only.py 项目： wxlg1117/pgcli

def test_cased_joins(completer, text):
    result = get_result(completer, text)
    assert completions_to_set(result) == completions_to_set([schema('PUBLIC')] + cased_rels + [
        join('"Users" ON "Users".UserID = Users.ID'),
        join('Users Users2 ON Users2.ID = Users.PARENTID'),
        join('Users Users2 ON Users2.PARENTID = Users.ID'),
    ])

示例#10

文件： test_smart_completion_public_schema_only.py 项目： piotrpawlaczek/pgcli

def test_cased_joins(completer, text):
    result = result_set(completer, text)
    assert result == set([schema('PUBLIC')] + cased_rels + [
        join('"Users" ON "Users".UserID = Users.ID'),
        join('Users Users2 ON Users2.ID = Users.PARENTID'),
        join('Users Users2 ON Users2.PARENTID = Users.ID'),
    ])

示例#11

文件： test_smart_completion_public_schema_only.py 项目： koumdros/pgcli

def test_cased_joins(cased_completer, complete_event, text):
    result = set(cased_completer.get_completions(
        Document(text=text), complete_event))
    assert set(result) == set([schema('PUBLIC')] + cased_rels + [
        join('"Users" ON "Users".UserID = Users.ID'),
        join('Users Users2 ON Users2.ID = Users.PARENTID'),
        join('Users Users2 ON Users2.PARENTID = Users.ID'),
        ])

示例#12

文件： test_smart_completion_public_schema_only.py 项目： LiuFang816/SALSTM_py_data

def test_cased_joins(cased_completer, complete_event, text):
    result = set(
        cased_completer.get_completions(Document(text=text), complete_event))
    assert set(result) == set([schema('PUBLIC')] + cased_rels + [
        join('"Users" ON "Users".UserID = Users.ID'),
        join('Users Users2 ON Users2.ID = Users.PARENTID'),
        join('Users Users2 ON Users2.PARENTID = Users.ID'),
    ])

示例#13

文件： test_smart_completion_public_schema_only.py 项目： piotrpawlaczek/pgcli

def test_duplicate_aliases_with_casing(completer, text):
    result = result_set(completer, text)
    assert result == set([
        schema('PUBLIC'),
        table('Orders O2'),
        table('Users U'),
        table('"Users" U'),
        table('"select" s'),
        view('User_Emails UE'),
        function('_custom_fun() cf'),
        function('Custom_Fun() CF'),
        function('Custom_Func1() CF'),
        function('custom_func2() cf'),
        function('set_returning_func() srf')])

示例#14

文件： test_smart_completion_public_schema_only.py 项目： thomasballinger/pgcli

def test_duplicate_aliases_with_casing(cased_aliased_completer,
                                        complete_event, text):
    result = cased_aliased_completer.get_completions(
        Document(text=text), complete_event)
    assert set(result) == set([
        schema('PUBLIC'),
        table('Orders O2'),
        table('Users U'),
        table('"Users" U'),
        table('"select" s'),
        view('User_Emails UE'),
        function('_custom_fun() cf'),
        function('Custom_Fun() CF'),
        function('Custom_Func1() CF'),
        function('custom_func2() cf'),
        function('set_returning_func() srf')])

示例#15

def test_duplicate_aliases_with_casing(completer, text):
    result = get_result(completer, text)
    assert completions_to_set(result) == completions_to_set([
        schema("PUBLIC"),
        table("Orders O2"),
        table("Users U"),
        table('"Users" U'),
        table('"select" s'),
        view("User_Emails UE"),
        view("Functions F"),
        function("_custom_fun() cf"),
        function("Custom_Fun() CF"),
        function("Custom_Func1() CF"),
        function("custom_func2() cf"),
        function(
            "set_returning_func(x := , y := ) srf",
            display="set_returning_func(x, y) srf",
        ),
    ])

示例#16

文件： test_smart_completion_public_schema_only.py 项目： wxlg1117/pgcli

def test_duplicate_aliases_with_casing(completer, text):
    result = get_result(completer, text)
    assert completions_to_set(result) == completions_to_set([
        schema('PUBLIC'),
        table('Orders O2'),
        table('Users U'),
        table('"Users" U'),
        table('"select" s'),
        view('User_Emails UE'),
        view('Functions F'),
        function('_custom_fun() cf'),
        function('Custom_Fun() CF'),
        function('Custom_Func1() CF'),
        function('custom_func2() cf'),
        function(
            'set_returning_func(x := , y := ) srf',
            display='set_returning_func(x, y) srf'
        ),
    ])

示例#17

文件： test_smart_completion_public_schema_only.py 项目： arthurli1126/pgcli

def test_list_functions_for_special(completer):
    result = result_set(completer, r'\df ')
    assert result == set(
        [schema('PUBLIC')] + [function(f) for f in cased_func_names]
    )

示例#18

文件： test_smart_completion_public_schema_only.py 项目： wxlg1117/pgcli

def test_list_functions_for_special(completer):
    result = get_result(completer, r'\df ')
    assert completions_to_set(result) == completions_to_set(
        [schema('PUBLIC')] + [function(f) for f in cased_func_names]
    )

示例#19

文件： test_smart_completion_public_schema_only.py 项目： LiuFang816/SALSTM_py_data

def test_table_casing(cased_completer, complete_event, text):
    result = cased_completer.get_completions(Document(text=text),
                                             complete_event)
    assert set(result) == set([schema('PUBLIC')] + cased_rels)

示例#20

文件： test_smart_completion_public_schema_only.py 项目： arthurli1126/pgcli

def test_aliases_with_casing(completer, text):
    result = result_set(completer, text)
    assert result == set([schema('PUBLIC')] + cased_aliased_rels)

示例#21

def test_aliases_with_casing(completer, text):
    result = get_result(completer, text)
    assert completions_to_set(result) == completions_to_set(
        [schema("PUBLIC")] + cased_aliased_rels)

示例#22

def test_list_functions_for_special(completer):
    result = result_set(completer, r'\df ')
    assert result == set([schema('PUBLIC')] +
                         [function(f) for f in cased_func_names])

示例#23

文件： test_smart_completion_public_schema_only.py 项目： arthurli1126/pgcli

def test_table_casing(completer, text):
    result = result_set(completer, text)
    assert result == set([schema('PUBLIC')] + cased_rels)

示例#24

文件： test_smart_completion_public_schema_only.py 项目： arthurli1126/pgcli

def test_set_schema(completer):
    text = ('SET SCHEMA ')
    result = result_set(completer, text)
    expected = set([schema(u"'public'")])
    assert result == expected

示例#25

            ("blog", "entries", "entryid", "blog", "entacclog", "entryid"),
            ("blog", "entries", "entryid", "blog", "entrytags", "entryid"),
            ("blog", "tags", "tagid", "blog", "entrytags", "tagid"),
        ],
    },
    "defaults": {
        "public": {
            ("orders", "id"): "nextval('orders_id_seq'::regclass)",
            ("orders", "datestamp"): "now()",
            ("orders", "status"): "'PENDING'::text",
        }
    },
}

testdata = MetaData(metadata)
cased_schemas = [schema(x) for x in ("public", "blog", "CUSTOM", '"Custom"')]
casing = (
    "SELECT",
    "Orders",
    "User_Emails",
    "CUSTOM",
    "Func1",
    "Entries",
    "Tags",
    "EntryTags",
    "EntAccLog",
    "EntryID",
    "EntryTitle",
    "EntryText",
)
completers = testdata.get_completers(casing)

示例#26

文件： test_smart_completion_public_schema_only.py 项目： piotrpawlaczek/pgcli

def test_table_casing(completer, text):
    result = result_set(completer, text)
    assert result == set([schema('PUBLIC')] + cased_rels)

示例#27

文件： test_smart_completion_multiple_schemata.py 项目： dbcli/pgcli

            ('blog', 'entries', 'entryid', 'blog', 'entacclog', 'entryid'),
            ('blog', 'entries', 'entryid', 'blog', 'entrytags', 'entryid'),
            ('blog', 'tags', 'tagid', 'blog', 'entrytags', 'tagid'),
        ],
    },
    'defaults': {
        'public': {
            ('orders', 'id'): "nextval('orders_id_seq'::regclass)",
            ('orders', 'datestamp'): "now()",
            ('orders', 'status'): "'PENDING'::text",
        }
    },
}

testdata = MetaData(metadata)
cased_schemas = [schema(x) for x in ('public', 'blog', 'CUSTOM', '"Custom"')]
casing = ('SELECT', 'Orders', 'User_Emails', 'CUSTOM', 'Func1', 'Entries',
          'Tags', 'EntryTags', 'EntAccLog',
          'EntryID', 'EntryTitle', 'EntryText')
completers = testdata.get_completers(casing)


@parametrize('completer', completers(filtr=True, casing=False, qualify=no_qual))
@parametrize('table', ['users', '"users"'])
def test_suggested_column_names_from_shadowed_visible_table(completer, table) :
    result = get_result(completer, 'SELECT  FROM ' + table, len('SELECT '))
    assert completions_to_set(result) == completions_to_set(
        testdata.columns_functions_and_keywords('users'))


@parametrize('completer', completers(filtr=True, casing=False, qualify=no_qual))

示例#28

文件： test_smart_completion_public_schema_only.py 项目： wxlg1117/pgcli

def test_set_schema(completer):
    text = ('SET SCHEMA ')
    result = get_result(completer, text)
    expected = completions_to_set([schema(u"'public'")])
    assert completions_to_set(result) == expected

示例#29

文件： test_smart_completion_public_schema_only.py 项目： koumdros/pgcli

def test_table_casing(cased_completer, complete_event, text):
    result = cased_completer.get_completions(
        Document(text=text), complete_event)
    assert set(result) == set([schema('PUBLIC')] + cased_rels)

示例#30

文件： test_smart_completion_public_schema_only.py 项目： wxlg1117/pgcli

def test_table_casing(completer, text):
    result = get_result(completer, text)
    assert completions_to_set(result) == completions_to_set(
        [schema('PUBLIC')] + cased_rels)

示例#31

def test_set_schema(completer):
    text = ('SET SCHEMA ')
    result = result_set(completer, text)
    expected = set([schema(u"'public'")])
    assert result == expected

示例#32

文件： test_smart_completion_multiple_schemata.py 项目： rjuju/pgcli

        'custom': ['typ3', 'typ4'],
     },
    'foreignkeys': {
        'custom': [
            ('public', 'users', 'id', 'custom', 'shipments', 'user_id')
        ],
        'blog': [
            ('blog', 'entries', 'entryid', 'blog', 'entacclog', 'entryid'),
            ('blog', 'entries', 'entryid', 'blog', 'entrytags', 'entryid'),
            ('blog', 'tags', 'tagid', 'blog', 'entrytags', 'tagid'),
        ],
    },
}

testdata = MetaData(metadata)
cased_schemas = [schema(x) for x in ('public', 'blog', 'CUSTOM', '"Custom"')]

@pytest.fixture
def completer():
    return testdata.completer

casing = ('SELECT', 'Orders', 'User_Emails', 'CUSTOM', 'Func1', 'Entries',
          'Tags', 'EntryTags', 'EntAccLog',
          'EntryID', 'EntryTitle', 'EntryText')

@pytest.fixture
def completer_with_casing():
    return testdata.get_completer(casing=casing)

@pytest.fixture
def completer_with_aliases():

示例#33

文件： test_smart_completion_public_schema_only.py 项目： piotrpawlaczek/pgcli

def test_aliases_with_casing(completer, text):
    result = result_set(completer, text)
    assert result == set([schema('PUBLIC')] + cased_aliased_rels)