#758

Committed 04 Sep 2023 08:37PM UTC coverage: 0.0% (-78.3%) from 78.333%

Build # #758

Build Type

push

circle-ci

Committed by

hershd23

Commit Message

Increased underline length in at line 75 in text_summarization.rst
	modified:   docs/source/benchmarks/text_summarization.rst

Run Details

0 of 11303 relevant lines covered (0.0%)

0.0 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/evadb/plan_nodes/load_data_plan.py

# coding=utf-8
# Copyright 2018-2023 EvaDB
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from pathlib import Path
from typing import List

from evadb.expression.abstract_expression import AbstractExpression
from evadb.parser.table_ref import TableInfo
from evadb.plan_nodes.abstract_plan import AbstractPlan
from evadb.plan_nodes.types import PlanOprType


class LoadDataPlan(AbstractPlan):
    """
    This plan is used for storing information required for load data
    operations.

    Arguments:
        table(TableCatalogEntry): table to load into
        file_path(Path): file path from where we will load the data
        batch_mem_size(int): memory size of the batch loaded from disk
    """

    def __init__(
        self,
        table_info: TableInfo,
        file_path: Path,
        column_list: List[AbstractExpression] = None,
        file_options: dict = None,
        batch_mem_size: int = 30000000,
    ):
        super().__init__(PlanOprType.LOAD_DATA)
        self._table_info = table_info
        self._file_path = file_path
        self._column_list = column_list
        self._file_options = file_options
        self._batch_mem_size = batch_mem_size

    @property
    def table_info(self):
        return self._table_info

    @property
    def file_path(self):
        return self._file_path

    @property
    def batch_mem_size(self):
        return self._batch_mem_size

    @property
    def column_list(self):
        return self._column_list

    @property
    def file_options(self):
        return self._file_options

    def __str__(self):
        return "LoadDataPlan(table_id={}, file_path={}, \
            column_list={}, \
            file_options={}, \
            batch_mem_size={})".format(
            self.table_info,
            self.file_path,
            self.column_list,
            self.file_options,
            self.batch_mem_size,
        )

    def __hash__(self) -> int:
        return hash(
            (
                super().__hash__(),
                self.table_info,
                self.file_path,
                tuple(self.column_list),
                frozenset(self.file_options.items()),
                self.batch_mem_size,
            )
        )

1	# coding=utf-8
2	# Copyright 2018-2023 EvaDB
3	#
4	# Licensed under the Apache License, Version 2.0 (the "License");
5	# you may not use this file except in compliance with the License.
6	# You may obtain a copy of the License at
7	#
8	# http://www.apache.org/licenses/LICENSE-2.0
9	#
10	# Unless required by applicable law or agreed to in writing, software
11	# distributed under the License is distributed on an "AS IS" BASIS,
12	# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13	# See the License for the specific language governing permissions and
14	# limitations under the License.
15	from pathlib import Path	×
16	from typing import List	×
17
18	from evadb.expression.abstract_expression import AbstractExpression	×
19	from evadb.parser.table_ref import TableInfo	×
20	from evadb.plan_nodes.abstract_plan import AbstractPlan	×
21	from evadb.plan_nodes.types import PlanOprType	×
22
23
24	class LoadDataPlan(AbstractPlan):	×
25	"""
26	This plan is used for storing information required for load data
27	operations.
28
29	Arguments:
30	table(TableCatalogEntry): table to load into
31	file_path(Path): file path from where we will load the data
32	batch_mem_size(int): memory size of the batch loaded from disk
33	"""
34
35	def __init__(	×
36	self,
37	table_info: TableInfo,
38	file_path: Path,
39	column_list: List[AbstractExpression] = None,
40	file_options: dict = None,
41	batch_mem_size: int = 30000000,
42	):
43	super().__init__(PlanOprType.LOAD_DATA)	×
44	self._table_info = table_info	×
45	self._file_path = file_path	×
46	self._column_list = column_list	×
47	self._file_options = file_options	×
48	self._batch_mem_size = batch_mem_size	×
49
50	@property	×
51	def table_info(self):	×
52	return self._table_info	×
53
54	@property	×
55	def file_path(self):	×
56	return self._file_path	×
57
58	@property	×
59	def batch_mem_size(self):	×
60	return self._batch_mem_size	×
61
62	@property	×
63	def column_list(self):	×
64	return self._column_list	×
65
66	@property	×
67	def file_options(self):	×
68	return self._file_options	×
69
70	def __str__(self):	×
71	return "LoadDataPlan(table_id={}, file_path={}, \	×
72	column_list={}, \
73	file_options={}, \
74	batch_mem_size={})".format(
75	self.table_info,
76	self.file_path,
77	self.column_list,
78	self.file_options,
79	self.batch_mem_size,
80	)
81
82	def __hash__(self) -> int:	×
83	return hash(	×
84	(
85	super().__hash__(),
86	self.table_info,
87	self.file_path,
88	tuple(self.column_list),
89	frozenset(self.file_options.items()),
90	self.batch_mem_size,
91	)
92	)

georgia-tech-db / eva / #758

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous