def select(self, select):
selects = listwrap(select)
if len(selects) == 1 and is_op(selects[0].value, Variable) and selects[0].value.var == ".":
new_schema = self.schema
if selects[0].name == ".":
return self
else:
new_schema = None
if is_list(select):
if all(
is_op(s.value, Variable) and s.name == s.value.var
for s in select
):
names = set(s.value.var for s in select)
new_schema = Schema(".", [c for c in self.schema.columns if c.name in names])
push_and_pull = [(s.name, jx_expression_to_function(s.value)) for s in selects]
def selector(d):
output = Data()
for n, p in push_and_pull:
output[n] = unwraplist(p(wrap(d)))
return unwrap(output)
new_data = map(selector, self.data)
else:
select_value = jx_expression_to_function(select.value)
new_data = map(select_value, self.data)
if is_op(select.value, Variable):
column = copy(first(c for c in self.schema.columns if c.name == select.value.var))
column.name = '.'
new_schema = Schema("from " + self.name, [column])
return ListContainer("from "+self.name, data=new_data, schema=new_schema)
def select(self, select):
selects = listwrap(select)
if len(selects) == 1 and is_op(selects[0].value, Variable) and selects[0].value.var == ".":
new_schema = self.schema
if selects[0].name == ".":
return self
else:
new_schema = None
if is_list(select):
if all(
is_op(s.value, Variable) and s.name == s.value.var
for s in select
):
names = set(s.value.var for s in select)
new_schema = Schema(".", [c for c in self.schema.columns if c.name in names])
push_and_pull = [(s.name, jx_expression_to_function(s.value)) for s in selects]
def selector(d):
output = Data()
for n, p in push_and_pull:
output[n] = unwraplist(p(to_data(d)))
return unwrap(output)
new_data = list(map(selector, self.data))
else:
select_value = jx_expression_to_function(select.value)
new_data = list(map(select_value, self.data))
if is_op(select.value, Variable):
column = dict(**first(c for c in self.schema.columns if c.name == select.value.var))
column.update({"name": ".", "jx_type": NESTED, "es_type": "nested", "multi":1001, "cardinality":1})
new_schema = Schema("from " + self.name, [Column(**column)])
return ListContainer("from "+self.name, data=new_data, schema=new_schema)
def get_schema_from_list(table_name, frum):
"""
SCAN THE LIST FOR COLUMN TYPES
"""
columns = UniqueIndex(keys=("name",))
_get_schema_from_list(frum, ".", parent=".", nested_path=ROOT_PATH, columns=columns)
return Schema(table_name=table_name, columns=list(columns))
def schema(self):
if not self._schema:
with self.locker:
self._update_meta()
self._schema = Schema(
".", [c for cs in self.data[META_COLUMNS_NAME].values() for c in cs]
)
return self._schema
def schema(self):
if not self._schema:
with self.locker:
self._update_meta()
self._schema = Schema(".", [
c for cs in self.data["meta.columns"].values() for c in cs
])
return self._schema
def query(self, query):
# NOT EXPECTED TO BE RUN
Log.error("not")
with self.locker:
self._update_meta()
if not self._schema:
self._schema = Schema(".", [
c for cs in self.data["meta.columns"].values() for c in cs
])
snapshot = self._all_columns()
from jx_python.containers.list_usingPythonList import ListContainer
query.frum = ListContainer("meta.columns", snapshot, self._schema)
return jx.run(query)
def __init__(
self,
host,
index,
type=None,
alias=None,
name=None,
port=9200,
read_only=True,
timeout=None, # NUMBER OF SECONDS TO WAIT FOR RESPONSE, OR SECONDS TO WAIT FOR DOWNLOAD (PASSED TO requests)
wait_for_active_shards=1, # ES WRITE CONSISTENCY (https://www.elastic.co/guide/en/elasticsearch/reference/1.7/docs-index_.html#index-consistency)
typed=None,
kwargs=None):
Container.__init__(self, None)
if not container.config.default:
container.config.default = {
"type": "elasticsearch",
"settings": unwrap(kwargs)
}
self.settings = kwargs
self.name = coalesce(name, alias, index)
if read_only:
self._es = elasticsearch.Alias(alias=coalesce(alias, index),
kwargs=kwargs)
else:
self._es = elasticsearch.Cluster(kwargs=kwargs).get_index(
read_only=read_only, kwargs=kwargs)
self.meta = FromESMetadata(kwargs=kwargs)
self.settings.type = self._es.settings.type
self.edges = Data()
self.worker = None
columns = self.meta.get_columns(
table_name=coalesce(name, alias, index))
self._schema = Schema(coalesce(name, alias, index), columns)
if typed == None:
# SWITCH ON TYPED MODE
self.typed = any(
c.es_column.find("." + TYPE_PREFIX) != -1 for c in columns)
else:
self.typed = typed
def get_schema(self, name):
if self.name != name:
Log.error("This container only has table by name of {{name}}",
name=name)
return self.schema
def get_table(self, name):
if self is name or self.name == name:
return self
Log.error("This container only has table by name of {{name}}",
name=name)
def _exec(code):
try:
temp = None
exec("temp = " + code)
return temp
except Exception as e:
Log.error("Could not execute {{code|quote}}", code=code, cause=e)
from jx_base.schema import Schema
from jx_python import jx
DUAL = ListContainer(name="dual",
data=[{}],
schema=Schema(table_name="dual",
columns=UniqueIndex(keys=("names.\\.", ))))