def get_views_columns(
user=Depends(dependencies.get_user),
json_object=Depends(dependencies.parse_json_object),
v_session=Depends(dependencies.get_omnidb_session),
v_database=dependencies.require_database(),
v_return=Depends(dependencies.get_default_return),
):
v_database_index = json_object["p_database_index"]
v_table = json_object["p_table"]
v_schema = json_object["p_schema"]
v_tab_id = json_object["p_tab_id"]
v_list_columns = []
try:
v_columns = v_database.QueryViewFields(v_table, False, v_schema)
for v_column in v_columns.Rows:
v_column_data = {
"v_column_name": v_column["column_name"],
"v_data_type": v_column["data_type"],
"v_data_length": v_column["data_length"],
}
v_list_columns.append(v_column_data)
except Exception as exc:
v_return["v_data"] = {"password_timeout": True, "message": str(exc)}
v_return["v_error"] = True
return v_return
v_return["v_data"] = v_list_columns
return v_return
def get_pk(
user=Depends(dependencies.get_user),
json_object=Depends(dependencies.parse_json_object),
v_session=Depends(dependencies.get_omnidb_session),
v_database=dependencies.require_database(),
v_return=Depends(dependencies.get_default_return),
):
v_database_index = json_object["p_database_index"]
v_table = json_object["p_table"]
v_schema = json_object["p_schema"]
v_tab_id = json_object["p_tab_id"]
v_list_pk = []
try:
v_pks = v_database.QueryTablesPrimaryKeys(v_table, False, v_schema)
for v_pk in v_pks.Rows:
v_pk_data = []
v_pk_data.append(v_pk["constraint_name"])
v_list_pk.append(v_pk_data)
except Exception as exc:
v_return["v_data"] = {"password_timeout": True, "message": str(exc)}
v_return["v_error"] = True
return v_return
v_return["v_data"] = v_list_pk
return v_return
def get_databases(
user=Depends(dependencies.get_user),
json_object=Depends(dependencies.parse_json_object),
v_session=Depends(dependencies.get_omnidb_session),
v_database=dependencies.require_database(),
v_return=Depends(dependencies.get_default_return),
):
v_database_index = json_object["p_database_index"]
v_tab_id = json_object["p_tab_id"]
v_list_databases = []
try:
v_databases = v_database.QueryDatabases()
for v_database in v_databases.Rows:
v_database_data = {"v_name": v_database[0]}
v_list_databases.append(v_database_data)
except Exception as exc:
v_return["v_data"] = {"password_timeout": True, "message": str(exc)}
v_return["v_error"] = True
return v_return
v_return["v_data"] = v_list_databases
return v_return
def get_views(
user=Depends(dependencies.get_user),
json_object=Depends(dependencies.parse_json_object),
v_session=Depends(dependencies.get_omnidb_session),
v_database=dependencies.require_database(),
v_return=Depends(dependencies.get_default_return),
):
v_database_index = json_object["p_database_index"]
v_schema = json_object["p_schema"]
v_tab_id = json_object["p_tab_id"]
v_list_tables = []
try:
v_tables = v_database.QueryViews(False, v_schema)
for v_table in v_tables.Rows:
v_table_data = {
"v_name": v_table["table_name"],
"v_has_triggers": v_database.v_has_triggers,
}
v_list_tables.append(v_table_data)
except Exception as exc:
v_return["v_data"] = {"password_timeout": True, "message": str(exc)}
v_return["v_error"] = True
return v_return
v_return["v_data"] = v_list_tables
return v_return
def get_procedure_fields(
user=Depends(dependencies.get_user),
json_object=Depends(dependencies.parse_json_object),
v_session=Depends(dependencies.get_omnidb_session),
v_database=dependencies.require_database(),
v_return=Depends(dependencies.get_default_return),
):
v_database_index = json_object["p_database_index"]
v_function = json_object["p_procedure"]
v_schema = json_object["p_schema"]
v_tab_id = json_object["p_tab_id"]
v_list_fields = []
try:
v_fields = v_database.QueryProcedureFields(v_function, v_schema)
for v_field in v_fields.Rows:
v_field_data = {
"v_name": v_field["name"],
"v_type": v_field["type"]
}
v_list_fields.append(v_field_data)
except Exception as exc:
v_return["v_data"] = {"password_timeout": True, "message": str(exc)}
v_return["v_error"] = True
return v_return
v_return["v_data"] = v_list_fields
return v_return
def get_indexes_columns(
user=Depends(dependencies.get_user),
json_object=Depends(dependencies.parse_json_object),
v_session=Depends(dependencies.get_omnidb_session),
v_database=dependencies.require_database(),
v_return=Depends(dependencies.get_default_return),
):
v_database_index = json_object["p_database_index"]
v_index = json_object["p_index"]
v_table = json_object["p_table"]
v_schema = json_object["p_schema"]
v_tab_id = json_object["p_tab_id"]
v_list_indexes = []
try:
v_indexes = v_database.QueryTablesIndexesColumns(
v_index, v_table, False, v_schema)
for v_index in v_indexes.Rows:
v_index_data = []
v_index_data.append(v_index["column_name"])
v_list_indexes.append(v_index_data)
except Exception as exc:
v_return["v_data"] = {"password_timeout": True, "message": str(exc)}
v_return["v_error"] = True
return v_return
v_return["v_data"] = v_list_indexes
return v_return
def get_fks_columns(
user=Depends(dependencies.get_user),
json_object=Depends(dependencies.parse_json_object),
v_session=Depends(dependencies.get_omnidb_session),
v_database=dependencies.require_database(),
v_return=Depends(dependencies.get_default_return),
):
v_database_index = json_object["p_database_index"]
v_fkey = json_object["p_fkey"]
v_table = json_object["p_table"]
v_schema = json_object["p_schema"]
v_tab_id = json_object["p_tab_id"]
v_list_fk = []
try:
v_fks = v_database.QueryTablesForeignKeysColumns(
v_fkey, v_table, False, v_schema)
for v_fk in v_fks.Rows:
v_fk_data = []
v_fk_data.append(v_fk["r_table_name"])
v_fk_data.append(v_fk["delete_rule"])
v_fk_data.append(v_fk["update_rule"])
v_fk_data.append(v_fk["column_name"])
v_fk_data.append(v_fk["r_column_name"])
v_list_fk.append(v_fk_data)
except Exception as exc:
v_return["v_data"] = {"password_timeout": True, "message": str(exc)}
v_return["v_error"] = True
return v_return
v_return["v_data"] = v_list_fk
return v_return
def get_properties(
user=Depends(dependencies.get_user),
json_object=Depends(dependencies.parse_json_object),
v_session=Depends(dependencies.get_omnidb_session),
v_database=dependencies.require_database(),
v_return=Depends(dependencies.get_default_return),
):
v_database_index = json_object["p_database_index"]
v_data = json_object["p_data"]
v_tab_id = json_object["p_tab_id"]
v_list_properties = []
v_ddl = ""
try:
v_properties = v_database.GetProperties(v_data["p_schema"],
v_data["p_table"],
v_data["p_object"],
v_data["p_type"])
for v_property in v_properties.Rows:
v_list_properties.append(
[v_property["Property"], v_property["Value"]])
v_ddl = v_database.GetDDL(v_data["p_schema"], v_data["p_table"],
v_data["p_object"], v_data["p_type"])
except Exception as exc:
v_return["v_data"] = {"password_timeout": True, "message": str(exc)}
v_return["v_error"] = True
return v_return
v_return["v_data"] = {"properties": v_list_properties, "ddl": v_ddl}
return v_return
def clear_console_list(
user=Depends(dependencies.get_user),
json_object=Depends(dependencies.parse_json_object),
v_session=Depends(dependencies.get_omnidb_session),
v_database=dependencies.require_database(),
v_return=Depends(dependencies.get_default_return),
):
v_database_index = json_object["p_database_index"]
v_command_contains = json_object["p_console_contains"]
v_command_from = json_object["p_console_from"]
v_command_to = json_object["p_console_to"]
v_database = v_session.v_databases[v_database_index]["database"]
try:
conn = Connection.objects.get(id=v_database.v_conn_id)
v_query = ConsoleHistory.objects.filter(
user=user, connection=conn,
snippet__icontains=v_command_contains).order_by("-start_time")
if v_command_from is not None and v_command_from != "":
v_query = v_query.filter(start_time__gte=v_command_from)
if v_command_to is not None and v_command_to != "":
v_query = v_query.filter(start_time__lte=v_command_to)
v_query.delete()
except Exception as exc:
v_return["v_data"] = str(exc)
v_return["v_error"] = True
return v_return
return v_return
def get_completions_table(
user=Depends(dependencies.get_user),
json_object=Depends(dependencies.parse_json_object),
v_session=Depends(dependencies.get_omnidb_session),
v_database=dependencies.require_database(),
v_return=Depends(dependencies.get_default_return),
):
p_database_index = json_object["p_database_index"]
p_tab_id = json_object["p_tab_id"]
p_table = json_object["p_table"]
p_schema = json_object["p_schema"]
if v_database.v_has_schema:
v_table_name = p_schema + "." + p_table
else:
v_table_name = p_table
v_list = []
try:
v_data1 = v_database.v_connection.GetFields("select x.* from " +
v_table_name +
" x where 1 = 0")
except Exception as exc:
v_return["v_data"] = {"password_timeout": True, "message": str(exc)}
v_return["v_error"] = True
return v_return
v_score = 100
# v_list.append ({'value': "t.", 'score': v_score, 'meta': ""})
v_score -= 100
for v_type in v_data1:
v_list.append({
"value": "t." + v_type.v_truename,
"score": v_score,
"meta": v_type.v_dbtype,
})
v_score -= 100
v_return["v_data"] = v_list
return v_return
def get_procedure_definition(
user=Depends(dependencies.get_user),
json_object=Depends(dependencies.parse_json_object),
v_session=Depends(dependencies.get_omnidb_session),
v_database=dependencies.require_database(),
v_return=Depends(dependencies.get_default_return),
):
v_database_index = json_object["p_database_index"]
v_function = json_object["p_procedure"]
v_tab_id = json_object["p_tab_id"]
try:
v_return["v_data"] = v_database.GetProcedureDefinition(v_function)
except Exception as exc:
v_return["v_data"] = {"password_timeout": True, "message": str(exc)}
v_return["v_error"] = True
return v_return
return v_return
def kill_backend(
user=Depends(dependencies.get_user),
json_object=Depends(dependencies.parse_json_object),
v_session=Depends(dependencies.get_omnidb_session),
v_database=dependencies.require_database(),
v_return=Depends(dependencies.get_default_return),
):
v_database_index = json_object["p_database_index"]
v_pid = json_object["p_pid"]
v_tab_id = json_object["p_tab_id"]
try:
v_data = v_database.Terminate(v_pid)
except Exception as exc:
v_return["v_data"] = {"password_timeout": True, "message": str(exc)}
v_return["v_error"] = True
return v_return
return v_return
def get_tables(
user=Depends(dependencies.get_user),
json_object=Depends(dependencies.parse_json_object),
v_session=Depends(dependencies.get_omnidb_session),
v_database=dependencies.require_database(),
v_return=Depends(dependencies.get_default_return),
):
v_database_index = json_object["p_database_index"]
v_schema = json_object["p_schema"]
v_tab_id = json_object["p_tab_id"]
v_list_tables = []
try:
v_tables = v_database.QueryTables(False, v_schema)
for v_table in v_tables.Rows:
v_table_data = {
"v_name": v_table["table_name"],
"v_has_primary_keys": v_database.v_has_primary_keys,
"v_has_foreign_keys": v_database.v_has_foreign_keys,
"v_has_uniques": v_database.v_has_uniques,
"v_has_indexes": v_database.v_has_indexes,
"v_has_checks": v_database.v_has_checks,
"v_has_excludes": v_database.v_has_excludes,
"v_has_rules": v_database.v_has_rules,
"v_has_triggers": v_database.v_has_triggers,
"v_has_partitions": v_database.v_has_partitions,
"v_has_statistics": v_database.v_has_statistics,
}
v_list_tables.append(v_table_data)
except Exception as exc:
v_return["v_data"] = {"password_timeout": True, "message": str(exc)}
v_return["v_error"] = True
return v_return
v_return["v_data"] = v_list_tables
return v_return
def refresh_monitoring(
user=Depends(dependencies.get_user),
json_object=Depends(dependencies.parse_json_object),
v_session=Depends(dependencies.get_omnidb_session),
v_database=dependencies.require_database(),
v_return=Depends(dependencies.get_default_return),
):
v_tab_id = json_object["p_tab_id"]
v_sql = json_object["p_query"]
try:
v_data = v_database.Query(v_sql, True, True)
v_return["v_data"] = {
"v_col_names": v_data.Columns,
"v_data": v_data.Rows,
"v_query_info": "Number of records: {0}".format(len(v_data.Rows)),
}
except Exception as exc:
v_return["v_data"] = {"password_timeout": True, "message": str(exc)}
v_return["v_error"] = True
return v_return
def template_update(
user=Depends(dependencies.get_user),
json_object=Depends(dependencies.parse_json_object),
v_session=Depends(dependencies.get_omnidb_session),
v_database=dependencies.require_database(),
v_return=Depends(dependencies.get_default_return),
):
v_database_index = json_object["p_database_index"]
v_tab_id = json_object["p_tab_id"]
v_table = json_object["p_table"]
v_schema = json_object["p_schema"]
try:
v_template = v_database.TemplateUpdate(v_schema, v_table).v_text
except Exception as exc:
v_return["v_data"] = {"password_timeout": True, "message": str(exc)}
v_return["v_error"] = True
return v_return
v_return["v_data"] = {"v_template": v_template}
return v_return
def get_tree_info(
user=Depends(dependencies.get_user),
json_object=Depends(dependencies.parse_json_object),
v_session=Depends(dependencies.get_omnidb_session),
v_database=dependencies.require_database(),
v_return=Depends(dependencies.get_default_return),
):
v_database_index = json_object["p_database_index"]
v_tab_id = json_object["p_tab_id"]
try:
v_return["v_data"] = {
"v_mode": "database",
"v_database_return": {
"v_database": v_database.GetName(),
"version": v_database.GetVersion(),
"v_username": v_database.GetUserName(),
"superuser": v_database.GetUserSuper(),
"create_role": v_database.TemplateCreateRole().v_text,
"alter_role": v_database.TemplateAlterRole().v_text,
"drop_role": v_database.TemplateDropRole().v_text,
#'create_tablespace': v_database.TemplateCreateTablespace().v_text,
#'alter_tablespace': v_database.TemplateAlterTablespace().v_text,
#'drop_tablespace': v_database.TemplateDropTablespace().v_text,
"create_database": v_database.TemplateCreateDatabase().v_text,
"alter_database": v_database.TemplateAlterDatabase().v_text,
"drop_database": v_database.TemplateDropDatabase().v_text,
#'create_sequence': v_database.TemplateCreateSequence().v_text,
#'alter_sequence': v_database.TemplateAlterSequence().v_text,
#'drop_sequence': v_database.TemplateDropSequence().v_text,
"create_function": v_database.TemplateCreateFunction().v_text,
"drop_function": v_database.TemplateDropFunction().v_text,
"create_procedure":
v_database.TemplateCreateProcedure().v_text,
"drop_procedure": v_database.TemplateDropProcedure().v_text,
#'create_triggerfunction': v_database.TemplateCreateTriggerFunction().v_text,
#'drop_triggerfunction': v_database.TemplateDropTriggerFunction().v_text,
"create_view": v_database.TemplateCreateView().v_text,
"drop_view": v_database.TemplateDropView().v_text,
"create_table": v_database.TemplateCreateTable().v_text,
"alter_table": v_database.TemplateAlterTable().v_text,
"drop_table": v_database.TemplateDropTable().v_text,
"create_column": v_database.TemplateCreateColumn().v_text,
"alter_column": v_database.TemplateAlterColumn().v_text,
"drop_column": v_database.TemplateDropColumn().v_text,
"create_primarykey":
v_database.TemplateCreatePrimaryKey().v_text,
"drop_primarykey": v_database.TemplateDropPrimaryKey().v_text,
"create_unique": v_database.TemplateCreateUnique().v_text,
"drop_unique": v_database.TemplateDropUnique().v_text,
"create_foreignkey":
v_database.TemplateCreateForeignKey().v_text,
"drop_foreignkey": v_database.TemplateDropForeignKey().v_text,
"create_index": v_database.TemplateCreateIndex().v_text,
"drop_index": v_database.TemplateDropIndex().v_text,
#'create_trigger': v_database.TemplateCreateTrigger().v_text,
#'create_view_trigger': v_database.TemplateCreateViewTrigger().v_text,
#'alter_trigger': v_database.TemplateAlterTrigger().v_text,
#'enable_trigger': v_database.TemplateEnableTrigger().v_text,
#'disable_trigger': v_database.TemplateDisableTrigger().v_text,
#'drop_trigger': v_database.TemplateDropTrigger().v_text,
#'create_partition': v_database.TemplateCreatePartition().v_text,
#'noinherit_partition': v_database.TemplateNoInheritPartition().v_text,
#'drop_partition': v_database.TemplateDropPartition().v_text
"delete": v_database.TemplateDelete().v_text,
},
}
except Exception as exc:
v_return["v_data"] = {"password_timeout": True, "message": str(exc)}
v_return["v_error"] = True
return v_return
return v_return
def get_completions(
user=Depends(dependencies.get_user),
json_object=Depends(dependencies.parse_json_object),
v_session=Depends(dependencies.get_omnidb_session),
v_database=dependencies.require_database(),
v_return=Depends(dependencies.get_default_return),
):
p_database_index = json_object["p_database_index"]
p_tab_id = json_object["p_tab_id"]
p_prefix = json_object["p_prefix"]
p_sql = json_object["p_sql"]
p_prefix_pos = json_object["p_prefix_pos"]
v_list = []
v_found = False
inst = get_positions(p_sql, p_prefix)
index = 0
for v_index in inst:
v_found = is_reference(p_sql, p_prefix, v_index, p_prefix_pos)
if v_found:
index = v_index
break
if not v_found:
v_return["v_data"] = v_list
return v_return
v_table = ""
while index > 0 and p_sql[index - 1] == " ":
index = index - 1
v_last_pos = index
if p_sql[v_last_pos - 1] == ")":
v_level = 0
while index > 0:
if p_sql[index - 1] == ")":
v_level = v_level - 1
elif p_sql[index - 1] == "(":
v_level = v_level + 1
if p_sql[index - 1] == "(" and v_level == 0:
break
index = index - 1
v_table = p_sql[index - 1:v_last_pos]
else:
v_quoted = False
if p_sql[index - 1] == '"':
v_quoted = True
while (index > 0 and (p_sql[index - 1] != " " or v_quoted)
and (p_sql[index - 1] != "," or v_quoted)):
index = index - 1
if p_sql[index - 2] == '"':
if v_quoted:
v_quoted = False
else:
v_quoted = True
v_first_pos = index
v_table = p_sql[v_first_pos:v_last_pos]
try:
v_data1 = v_database.v_connection.GetFields("select x.* from " +
v_table + " x where 1 = 0")
except Exception as exc:
v_return["v_data"] = {"password_timeout": True, "message": str(exc)}
v_return["v_error"] = True
return v_return
v_score = 100
v_score -= 100
for v_type in v_data1:
v_list.append({
"value": p_prefix + "." + v_type.v_truename,
"score": v_score,
"meta": v_type.v_dbtype,
})
v_score -= 100
v_return["v_data"] = v_list
return v_return
def start_edit_data(
user=Depends(dependencies.get_user),
json_object=Depends(dependencies.parse_json_object),
v_session=Depends(dependencies.get_omnidb_session),
v_database=dependencies.require_database(),
v_return=Depends(dependencies.get_default_return),
):
v_database_index = json_object["p_database_index"]
v_tab_id = json_object["p_tab_id"]
v_table = json_object["p_table"]
if v_database.v_has_schema:
v_schema = json_object["p_schema"]
v_return["v_data"] = {"v_pk": [], "v_cols": [], "v_ini_orderby": ""}
try:
if v_database.v_has_schema:
v_pk = v_database.QueryTablesPrimaryKeys(v_table, False, v_schema)
v_table_name = v_schema + "." + v_table
v_columns = v_database.QueryTablesFields(v_table, False, v_schema)
else:
v_pk = v_database.QueryTablesPrimaryKeys(v_table)
v_table_name = v_table
v_columns = v_database.QueryTablesFields(v_table)
v_pk_cols = None
if v_pk != None and len(v_pk.Rows) > 0:
if v_database.v_has_schema:
v_pk_cols = v_database.QueryTablesPrimaryKeysColumns(
v_pk.Rows[0]["constraint_name"], v_table, False, v_schema)
else:
v_pk_cols = v_database.QueryTablesPrimaryKeysColumns(v_table)
v_return["v_data"]["v_ini_orderby"] = "ORDER BY "
v_first = True
for v_pk_col in v_pk_cols.Rows:
if not v_first:
v_return["v_data"]["v_ini_orderby"] = (
v_return["v_data"]["v_ini_orderby"] + ", ")
v_first = False
v_return["v_data"]["v_ini_orderby"] = (
v_return["v_data"]["v_ini_orderby"] + "t." +
v_pk_col["column_name"])
v_index = 0
for v_column in v_columns.Rows:
v_col = {}
v_col["v_type"] = v_column["data_type"]
v_col["v_column"] = v_column["column_name"]
v_col["v_is_pk"] = False
# Finding corresponding PK column
if v_pk_cols != None:
for v_pk_col in v_pk_cols.Rows:
if (v_pk_col["column_name"].lower() ==
v_column["column_name"].lower()):
v_col["v_is_pk"] = True
v_pk_info = {}
v_pk_info["v_column"] = v_pk_col["column_name"]
v_pk_info["v_index"] = v_index
v_pk_info["v_type"] = v_column["data_type"]
v_return["v_data"]["v_pk"].append(v_pk_info)
break
v_return["v_data"]["v_cols"].append(v_col)
v_index = v_index + 1
except Exception as exc:
v_return["v_data"] = {"password_timeout": True, "message": str(exc)}
v_return["v_error"] = True
return v_return
def draw_graph(
user=Depends(dependencies.get_user),
json_object=Depends(dependencies.parse_json_object),
v_session=Depends(dependencies.get_omnidb_session),
v_database=dependencies.require_database(),
v_return=Depends(dependencies.get_default_return),
):
v_database_index = json_object["p_database_index"]
v_tab_id = json_object["p_tab_id"]
v_complete = json_object["p_complete"]
v_schema = json_object["p_schema"]
v_nodes = []
v_edges = []
try:
v_tables = v_database.QueryTables(False, v_schema)
for v_table in v_tables.Rows:
v_node_data = {
"id": v_table["table_name"],
"label": v_table["table_name"],
"group": 1,
}
if v_complete:
v_node_data["label"] += "\n"
v_columns = v_database.QueryTablesFields(
v_table["table_name"], False, v_schema)
for v_column in v_columns.Rows:
v_node_data["label"] += (v_column["column_name"] + " : " +
v_column["data_type"] + "\n")
v_nodes.append(v_node_data)
v_data = v_database.QueryTablesForeignKeys(None, False, v_schema)
v_curr_constraint = ""
v_curr_from = ""
v_curr_to = ""
v_curr_to_schema = ""
for v_fk in v_data.Rows:
if v_curr_constraint != "" and v_curr_constraint != v_fk[
"constraint_name"]:
v_edge = {
"from": v_curr_from,
"to": v_curr_to,
"label": "",
"arrows": "to",
}
# FK referencing other schema, create a new node if it isn't in v_nodes list.
if v_database.v_schema != v_curr_to_schema:
v_found = False
for k in range(len(v_nodes) - 1, 0):
if v_nodes[k]["label"] == v_curr_to:
v_found = True
break
if not v_found:
v_node = {
"id": v_curr_to,
"label": v_curr_to,
"group": 0
}
v_nodes.append(v_node)
v_edges.append(v_edge)
v_curr_constraint = ""
v_curr_from = v_fk["table_name"]
v_curr_to = v_fk["r_table_name"]
v_curr_constraint = v_fk["constraint_name"]
v_curr_to_schema = v_fk["r_table_schema"]
if v_curr_constraint != "":
v_edge = {
"from": v_curr_from,
"to": v_curr_to,
"label": "",
"arrows": "to"
}
v_edges.append(v_edge)
# FK referencing other schema, create a new node if it isn't in v_nodes list.
if v_database.v_schema != v_curr_to_schema:
v_found = False
for k in range(len(v_nodes) - 1, 0):
if v_nodes[k]["label"] == v_curr_to:
v_found = True
break
if not v_found:
v_node = {"id": v_curr_to, "label": v_curr_to, "group": 0}
v_nodes.append(v_node)
v_return["v_data"] = {"v_nodes": v_nodes, "v_edges": v_edges}
except Exception as exc:
v_return["v_data"] = {"password_timeout": True, "message": str(exc)}
v_return["v_error"] = True
return v_return
def get_autocomplete_results(
user=Depends(dependencies.get_user),
json_object=Depends(dependencies.parse_json_object),
v_session=Depends(dependencies.get_omnidb_session),
v_database=dependencies.require_database(),
v_return=Depends(dependencies.get_default_return),
):
v_database_index = json_object["p_database_index"]
v_tab_id = json_object["p_tab_id"]
v_sql = json_object["p_sql"]
v_value = json_object["p_value"]
v_pos = json_object["p_pos"]
v_num_dots = v_value.count(".")
v_result = []
max_result_word = ""
max_complement_word = ""
v_alias = None
if v_value != "" and v_value[len(v_value) - 1] == ".":
v_alias = get_alias(v_sql, v_pos, v_value)
if v_alias:
try:
v_data1 = v_database.v_connection.GetFields(
"select x.* from " + v_alias + " x where 1 = 0")
v_current_group = {"type": "column", "elements": []}
max_result_length = 0
max_complement_length = 0
for v_type in v_data1:
curr_result_length = len(v_value + v_type.v_truename)
curr_complement_length = len(v_type.v_dbtype)
curr_result_word = v_value + v_type.v_truename
curr_complement_word = v_type.v_dbtype
if curr_result_length > max_result_length:
max_result_length = curr_result_length
max_result_word = curr_result_word
if curr_complement_length > max_complement_length:
max_complement_length = curr_complement_length
max_complement_word = curr_complement_word
v_current_group["elements"].append({
"value":
v_value + v_type.v_truename,
"select_value":
v_value + v_type.v_truename,
"complement":
v_type.v_dbtype,
})
if len(v_current_group["elements"]) > 0:
v_result.append(v_current_group)
except Exception as exc:
pass
if not v_alias:
v_filter = """where search.result like '{0}%' """.format(v_value)
v_query_columns = "type,sequence,result,select_value,complement"
if v_num_dots > 0:
v_filter = """where search.result_complete like '{0}%' and search.num_dots <= {1}""".format(
v_value, v_num_dots)
v_query_columns = "type,sequence,result_complete as result,select_value,complement_complete as complement"
elif v_value == "":
v_filter = """where search.num_dots = 0 """
try:
max_result_length = 0
max_complement_length = 0
v_search = v_database.GetAutocompleteValues(
v_query_columns, v_filter)
if v_search != None:
v_current_group = {"type": "", "elements": []}
if len(v_search.Rows) > 0:
v_current_group["type"] = v_search.Rows[0]["type"]
for v_search_row in v_search.Rows:
if v_current_group["type"] != v_search_row["type"]:
v_result.append(v_current_group)
v_current_group = {
"type": v_search_row["type"],
"elements": []
}
curr_result_length = len(v_search_row["result"])
curr_complement_length = len(v_search_row["complement"])
curr_result_word = v_search_row["result"]
curr_complement_word = v_search_row["complement"]
v_current_group["elements"].append({
"value":
v_search_row["result"],
"select_value":
v_search_row["select_value"],
"complement":
v_search_row["complement"],
})
if curr_result_length > max_result_length:
max_result_length = curr_result_length
max_result_word = curr_result_word
if curr_complement_length > max_complement_length:
max_complement_length = curr_complement_length
max_complement_word = curr_complement_word
if len(v_current_group["elements"]) > 0:
v_result.append(v_current_group)
except Exception as exc:
v_return["v_data"] = {
"password_timeout": True,
"message": str(exc)
}
v_return["v_error"] = True
return v_return
v_return["v_data"] = {
"data": v_result,
"max_result_word": max_result_word,
"max_complement_word": max_complement_word,
}
return v_return
