Struct mz_sql_parser::ast::defs::name::Ident

source ·

pub struct Ident(pub(crate) String);

Expand description

An identifier.

Tuple Fields§

§0: String

Implementations§

source §

impl Ident

source

pub const MAX_LENGTH: usize = 255usize

Maximum length of an identifier in Materialize.

source

pub fn new<S>(s: S) -> Result<Self, IdentError>
where S: TryInto<IdentString>, <S as TryInto<IdentString>>::Error: Display,

Create a new Ident with the given value, checking our invariants.

§Examples

use mz_sql_parser::ast::Ident;

let id = Ident::new("hello_world").unwrap();
assert_eq!(id.as_str(), "hello_world");

let too_long = "I am a very long identifier that is more than 255 bytes long which is the max length for idents.\
😊😁😅😂😬🍻😮‍💨😮🗽🛰️🌈😊😁😅😂😬🍻😮‍💨😮🗽🛰️🌈😊😁😅😂😬🍻😮‍💨😮🗽🛰️🌈";
assert_eq!(too_long.len(), 258);

let too_long_id = Ident::new(too_long);
assert!(too_long_id.is_err());

let invalid_name_dot = Ident::new(".");
assert!(invalid_name_dot.is_err());

let invalid_name_dot_dot = Ident::new("..");
assert!(invalid_name_dot_dot.is_err());

source

pub fn new_lossy<S: Into<String>>(value: S) -> Self

Create a new Ident modifying the given value as necessary to meet our invariants.

§Examples

use mz_sql_parser::ast::Ident;

let too_long = "🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢\
🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵\
🔴🔴🔴🔴🔴🔴🔴🔴🔴🔴🔴🔴🔴🔴🔴🔴🔴🔴🔴🔴🔴🔴🔴🔴🔴🔴🔴🔴🔴🔴🔴🔴";

let id = Ident::new_lossy(too_long);

// `new_lossy` will truncate the provided string, since it's too long. Note the missing
// `🔴` characters.
assert_eq!(id.as_str(), "🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵");

source

pub fn new_unchecked<S: Into<String>>(value: S) -> Self

Create a new Ident without checking any of our invariants.

NOTE: Generally you should not use this function! If you’re trying to create an Ident from a &'static str you know is valid, use the ident! macro. For all other use cases, see Ident::new which correctly checks our invariants.

source

pub fn try_generate_name<P, S, F, E>( prefix: P, suffix: S, is_valid: F, ) -> Result<Self, E>
where P: Into<String>, S: Into<String>, E: From<IdentError>, F: FnMut(&Ident) -> Result<bool, E>,

Generate a valid Ident with the provided prefix and suffix.

§Examples

use mz_sql_parser::ast::{Ident, IdentError};

let good_id =
  Ident::try_generate_name("hello", "_world", |_| Ok::<_, IdentError>(true)).unwrap();
assert_eq!(good_id.as_str(), "hello_world");

// Return invalid once.
let mut attempts = 0;
let one_failure = Ident::try_generate_name("hello", "_world", |_candidate| {
    if attempts == 0 {
        attempts += 1;
        Ok::<_, IdentError>(false)
    } else {
        Ok(true)
    }
})
.unwrap();

// We "hello_world" was invalid, so we appended "_1".
assert_eq!(one_failure.as_str(), "hello_world_1");

source

pub fn append_lossy<S: Into<String>>(&mut self, suffix: S)

Append the provided suffix, truncating self as necessary to satisfy our invariants.

Note: We soft-assert that the provided suffix is not too long, if it is, we’ll truncate it.

§Examples

use mz_sql_parser::{
    ident,
    ast::Ident,
};

let mut id = ident!("🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵🔵");
id.append_lossy("🔴🔴🔴🔴🔴🔴🔴🔴🔴🔴🔴🔴🔴🔴🔴🔴🔴🔴🔴🔴🔴🔴🔴🔴🔴🔴🔴🔴🔴🔴🔴🔴");

// We truncated the original ident, removing all '🔵' chars.
assert_eq!(id.as_str(), "🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🔴🔴🔴🔴🔴🔴🔴🔴🔴🔴🔴🔴🔴🔴🔴🔴🔴🔴🔴🔴🔴🔴🔴🔴🔴🔴🔴🔴🔴🔴🔴🔴");

§Too long suffix

If the provided suffix is too long, we’ll also truncate that.

use mz_sql_parser::{
    ident,
    ast::Ident,
};

let mut stem = ident!("hello___world");

let too_long_suffix = "\
🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢\
🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢\
🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢\
🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🔵🔵\
";

stem.append_lossy(too_long_suffix);

// Notice the "hello___world" stem got truncated, as did the "🔵🔵" characters from the suffix.
let result = "hello___wor\
🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢\
🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢\
🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢\
🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢\
";
assert_eq!(stem.as_str(), result);