def validate_type(value: Any) -> None:
if not isinstance(value, list):
raise error.ValidationError('{} is not of type list'.format(value))
for item in value:
if not isinstance(item, str):
raise error.ValidationError(
'{} is not of type str'.format(item))
def _validate(self, model_class: Type[Any]) -> None:
if self.column not in model_class.fields:
raise error.ValidationError('{} is not a column on {}'.format(
self.column, model_class.table))
if self.field and self.field != model_class.fields[self.column]:
raise error.ValidationError('{} does not belong to {}'.format(
self.column, model_class.table))
model_class.fields[self.column].validate(self.value)
def validate_type(value: Any) -> None:
if not isinstance(value, list):
raise error.ValidationError("{} is not of type list".format(value))
for item in value:
try:
datetime.datetime.strptime(item, "%Y-%m-%d")
except:
raise error.ValidationError(
"{} is not of type date (YYYY-[M]M-[D]D)".format(item)
)
def _validate(self, model_class: Type[Any]) -> None:
if self.name not in model_class.relations:
raise error.ValidationError("{} is not a relation on {}".format(
self.name, model_class.table))
if self.relation and self.relation != model_class.relations[self.name]:
raise error.ValidationError("{} does not belong to {}".format(
self.relation.name, model_class.table))
other_model_class = model_class.relations[self.name].destination
for condition in self._conditions:
condition._validate(other_model_class) # pylint: disable=protected-access
def _validate(self, model_class: Type[Any]) -> None:
if self.name not in model_class.indexes:
raise error.ValidationError('{} is not an index on {}'.format(
self.name, model_class.table))
if self.index and self.index != model_class.indexes[self.name]:
raise error.ValidationError('{} does not belong to {}'.format(
self.index.name, model_class.table))
if model_class.indexes[self.name].primary:
raise error.ValidationError(
'Cannot force query using primary index')
def _validate(self, model_class: Type[Any]) -> None:
if not isinstance(self.value, list):
raise error.ValidationError("{} is not a list".format(self.value))
if self.column not in model_class.fields:
raise error.ValidationError("{} is not a column on {}".format(
self.column, model_class.table))
if self.field and self.field != model_class.fields[self.column]:
raise error.ValidationError("{} does not belong to {}".format(
self.column, model_class.table))
for value in self.value:
model_class.fields[self.column].validate(value)
def _validate(self, model_class: Type[Any]) -> None:
for idx in model_class.indexes.values():
if idx.name == self.name and (self.index is None
or self.index == idx):
if idx.primary:
raise error.ValidationError(
"Cannot force query using primary index")
self.index = idx
break
else:
raise error.ValidationError("{} is not an index on {}".format(
self.name, model_class.table))
def _validate(self, model_class: Type[Any]) -> None:
"""See base class."""
for substitution in self._substitutions.values():
if isinstance(substitution, field.Field):
if substitution not in model_class.fields.values():
raise error.ValidationError(
f'Field {substitution.name!r} does not belong to the Model for '
f'table {model_class.table!r}.')
elif isinstance(substitution, Column):
if substitution.name not in model_class.fields:
raise error.ValidationError(
f'Column {substitution.name!r} does not exist in the Model for '
f'table {model_class.table!r}.')
def _validate(self, model_class: Type[Any]) -> None:
if self.column not in model_class.fields:
raise error.ValidationError("{} is not a column on {}".format(
self.column, model_class.table))
origin = model_class.fields[self.column]
if self.destination_column not in self.destination_model_class.fields:
raise error.ValidationError("{} is not a column on {}".format(
self.destination_column, self.destination_model_class.table))
dest = self.destination_model_class.fields[self.destination_column]
if origin.field_type != dest.field_type or origin.nullable != dest.nullable:
raise error.ValidationError(
"Types of {} and {} do not match".format(
origin.name, dest.name))
def _validate(self, model_class: Type[Any]) -> None:
for (column, _) in self.orderings:
if isinstance(column, field.Field):
column = column.name
if column not in model_class.fields:
raise error.ValidationError('{} is not a column on {}'.format(
column, model_class.table))
def validate_type(value) -> None:
try:
datetime.datetime.strptime(value, "%Y-%m-%d")
except:
raise error.ValidationError(
"{} is not of type date (YYYY-[M]M-[D]D)".format(value)
)
def validate(self, value) -> None:
if value is None:
if not self._nullable:
raise error.ValidationError("None set for non-nullable field")
elif self._allow_commit_timestamp and value == COMMIT_TIMESTAMP:
return
else:
self._type.validate_type(value)
def _parse_constraints(self) -> List[RelationshipConstraint]:
"""Validates the dictionary of constraints and turns it into Conditions."""
constraints = []
for origin_column, destination_column in self._constraints.items():
if origin_column not in self.origin.fields:
raise error.ValidationError(
'Origin column must be present in origin model')
if destination_column not in self.destination.fields:
raise error.ValidationError(
'Destination column must be present in destination model')
constraints.append(
RelationshipConstraint(self.destination, destination_column,
self.origin, origin_column))
return constraints
def _validate(self, model_class: Type[Any]) -> None:
if self.foreign_key_relation:
model_class_relations = model_class.foreign_key_relations
referenced_table_fn = lambda x: x.constraint.referenced_table
else:
model_class_relations = model_class.relations
referenced_table_fn = lambda x: x.destination
if self.name not in model_class_relations:
raise error.ValidationError('{} is not a relation on {}'.format(
self.name, model_class.table))
if self.relation and self.relation != model_class_relations[self.name]:
raise error.ValidationError('{} does not belong to {}'.format(
self.relation.name, model_class.table))
other_model_class = referenced_table_fn(
model_class_relations[self.name])
for condition in self._conditions:
condition._validate(other_model_class) # pylint: disable=protected-access
def _parse_constraints(self) -> List[RelationshipConstraint]:
"""Validates the dictionary of constraints and turns it into Conditions."""
constraints = []
for origin_column, destination_column in self._constraints.items():
if origin_column not in self.origin.fields:
raise error.ValidationError(
"Origin column must be present in origin model")
if destination_column not in self.destination.fields:
raise error.ValidationError(
"Destination column must be present in destination model")
# TODO(dbrandao): remove when pytype #234 is fixed
constraints.append(
RelationshipConstraint(self.destination, destination_column,
self.origin,
origin_column)) # type: ignore
return constraints
def __init__(
self,
columns: List[str],
parent: Optional[str] = None,
null_filtered: bool = False,
unique: bool = False,
storing_columns: Optional[List[str]] = None,
name: Optional[str] = None,
column_ordering: Union[Dict[str, bool], bool] = None,
):
"""
Represents an index on the table
:param columns: List of columns in the index
:param parent:
:param null_filtered: Should null values be filtered?
:param unique: Enforce unique constraint?
:param storing_columns: Additional columns to store with this index. This can help performance if fields are
accessed together
:param name: Name of the index (this may be used to customize default index name)
:param column_ordering: Map of column names to bool (True for ASC, and False for DESC) indicating order for the
field (defaults to ASC). For single column indexes, this can be a single bool value as well.
"""
if not columns:
raise error.ValidationError("An index must have at least one column")
if isinstance(column_ordering, bool):
if len(columns) != 1:
raise error.ValidationError(
"column_ordering can be set to a bool only if single-column index"
)
column_ordering = {columns[0]: column_ordering}
self._columns = columns
self._name = name
self._parent = parent
self._null_filtered = null_filtered
self._unique = unique
self._storing_columns = storing_columns or []
self._column_ordering = column_ordering or {}
def __init__(self,
columns: List[str],
parent: Optional[str] = None,
null_filtered: bool = False,
unique: bool = False,
storing_columns: Optional[List[str]] = None):
if not columns:
raise error.ValidationError('An index must have at least one column')
self.columns = columns
self.name = None
self.parent = parent
self.null_filtered = null_filtered
self.unique = unique
self.storing_columns = storing_columns or []
def __init__(
self,
field_type: Type[FieldType],
nullable: bool = False,
primary_key: bool = False,
allow_commit_timestamp: bool = False,
name: Optional[str] = None,
size: Optional[int] = None,
):
self._name = name
self._size = size
self._type = field_type
self._nullable = nullable
self._primary_key = primary_key
self._allow_commit_timestamp = allow_commit_timestamp
if self._type.ddl() != "TIMESTAMP" and self._allow_commit_timestamp:
raise error.ValidationError(
"allow_commit_timestamp can not be set on field {}".format(self._type)
)
def validate_type(value: Any) -> None:
if not isinstance(value, bool):
raise error.ValidationError('{} is not of type bool'.format(value))
def validate(self, value) -> None:
if value is None:
if not self._nullable:
raise error.ValidationError('None set for non-nullable field')
else:
self._type.validate_type(value)
def validate_type(value: Any) -> None:
if not isinstance(value, datetime.datetime):
raise error.ValidationError(
'{} is not of type datetime'.format(value))
def _validate(self, model_class: Type[Any]) -> None:
if self.field in model_class.columns:
raise error.ValidationError(
f"Invalid alias name: {self.field} already in in model class: {model_class}"
)
def validate_type(value) -> None:
if not isinstance(value, str):
raise error.ValidationError('{} is not of type str'.format(value))
def constraints(self) -> List[RelationshipConstraint]:
if not self.origin:
raise error.ValidationError(
"Origin must be set before constraints is called")
return self._parse_constraints()
def validate_type(value: Any) -> None:
if not isinstance(value, list):
raise error.ValidationError("{} is not of type list".format(value))
for item in value:
if not isinstance(item, float):
raise error.ValidationError("{} is not of type float".format(item))
def validate_type(value: Any) -> None:
if not isinstance(value, (int, float)):
raise error.ValidationError(
"{} is not of type float".format(value))
def _validate(self, model_class: Type[Any]) -> None:
for column in self.columns:
if column not in model_class.columns:
raise error.ValidationError(
f"Invalid column name: {column} not in model class: {model_class}"
)
