'hU`%SSKJr SSKrSSKrSSKJrJrJrJrJ r SSK J r SSK J r SSKJr SSKJr SSKJrJr SS KJr SS KJrJr SS KJr SS KJrJr SS KJr SSKJ!r" SSK#J$r$ SSK%J&r& \RN"\(5 SSK)J*r* SSS5 \(aSSK+r+SSK,J-r-J.r. SSK/J0r0 SSKJ1r1J2r2J3r3 \+RhS:aSSKJ5r5 OSSK6J5r5 \+RhS:aSSKJ7r7 OSSK6J7r7 \\\$\&\ R6\ RL\1\"Rp\"Rr4r:S\;S'S/rSSS.S#Sjjr?"S S\\ 5r@g!,(df  N=f)$) annotationsN) TYPE_CHECKINGCallableGenericUnionoverload) FrameType)deprecate_renamed_parameter) is_pycapsule)issue_unstable_warning)_get_stack_localsqualified_type_name)wrap_ldf) from_arrow from_pandas) DataFrame)_check_for_pandas_check_for_pyarrow)pandas)pyarrow) LazyFrame)Series) PySQLContext) CollectionMapping) TracebackType)AnyFinalLiteral) ) TypeAlias)r )Selfr"CompatibleFrameType SQLContextcR[U5=(d [U[5=(d [U5=(a* [U[R [R 45=(d< [U5=(a* [U[R[R45$)z2Check if the object can be converted to DataFrame.) r isinstancerrpdrrrpaTable RecordBatch)objs eC:\Users\julio\OneDrive\Documentos\Trabajo\Ideas Frescas\venv\Lib\site-packages\polars/sql/context.py_compatible_framer/;sq S U c9 % U c " Qz# bii7P'Q U s # S 32>>8R(S c[U[[45(aUR5$[U[5(aUR 5R5$[ U5(ao[U[R[R45(a@[[U5=n[5(aUR 5nUR5$[U5(d?[U5(aH[U[R[R45(a[U5R5$S[U53n[!U5e)z'Return LazyFrame from compatible input.zunrecognised frame type: )r(rrlazyrto_framerr)rr rr*r+r,rr ValueError)r-framemsgs r._ensure_lazyframer7Es# 9-..xxz C ||~""$$ 3  JsR\\2994M$N$N {3//e 8 8NN$Ezz| c  3JsRXXr~~4N$O$O###%%)*=c*B)CDor0) n_objectsnamedcRU(a[O[[[4n[ X1US9$)z5Return compatible frame objects from the local stack.)of_typer8r9)r/rrrr )all_compatibler8r9r;s r._get_frame_localsr=Xs"$2 9f7UG W OOr0cv\rSrSr%SrS\S'S\S'S\S'\S/S S S S .S0S jjj5r\S/S S S.S1Sjjj5r\S/S S S.S2Sjjj5r\"SS SS9S3S S S.S4Sjjj5r\\ S S.S5Sjj55r \\ S6Sj55r \\ S7Sj55r \ S S.S7Sjj5r S8Sjr S9Sjr S:Sjr \S S.S;Sjj5r\SS"jj5r\S?S#j5r\S@S$j5r\S S.SAS%jj5rSS.SAS&jjrSBS'jrS3S(S).SCS*jjjrS3SDS+jjrSES,jrSFS-jrS.rg)Gr&ca Run SQL queries against DataFrame, LazyFrame, and Series data. .. warning:: This functionality is considered **unstable**, although it is close to being considered stable. It may be changed at any point without it being considered a breaking change. r_ctxtz Final[bool]_eager_executionzlist[set[str]]_tables_scope_stack.F)register_globalsr<eagerrDc gNselfframesrCr<rD named_framess r.__init__SQLContext.__init__wr0)rCr<c grFrGrHs r.rLrMrNr0c grFrGrHs r.rLrMrNr0eager_executionz0.20.31)versionN)rCrDc V[S5 [R"5UlX0l[ U=(d 05nU(a2[ SS9R5HupVXQ;dM XT;dMXdU'M U(dU(a#URU5 URU5 gg)u Initialize a new `SQLContext`. .. versionchanged:: 0.20.31 The `eager_execution` parameter was renamed `eager`. Parameters ---------- frames A `{name:frame, ...}` mapping which can include Polars frames *and* pandas DataFrames, Series and pyarrow Table and RecordBatch objects. register_globals Register compatible objects (polars DataFrame, LazyFrame, and Series) found in the globals, automatically mapping their variable name to a table name. To register other objects (pandas/pyarrow data) pass them explicitly, or call the `execute_global` classmethod. If given an integer then only the most recent "n" objects found will be registered. eager If True, returns execution results as `DataFrame` instead of `LazyFrame`. (Note that the query itself is always executed in lazy-mode; this parameter impacts whether :meth:`execute` returns an eager or lazy result frame). **named_frames Named eager/lazy frames, provided as kwargs. Examples -------- >>> lf = pl.LazyFrame({"a": [1, 2, 3], "b": ["x", None, "z"]}) >>> res = pl.SQLContext(frame=lf).execute( ... "SELECT b, a*2 AS two_a FROM frame WHERE b IS NOT NULL" ... ) >>> res.collect() shape: (2, 2) ┌─────┬───────┐ │ b ┆ two_a │ │ --- ┆ --- │ │ str ┆ i64 │ ╞═════╪═══════╡ │ x ┆ 2 │ │ z ┆ 6 │ └─────┴───────┘ zY`SQLContext` is considered **unstable**, although it is close to being considered stable.Fr<N) r rnewr@rAdictr=itemsupdate register_many)rIrJrCrDrKnamer-s r.rLrMsd  g "%%' %fl# .$eg %$*B),&  \ MM, '   v &"r0)rDcgrFrGclsqueryrDs r.execute_globalSQLContext.execute_globalsr0cgrFrGr\s r.r_r`sORr0cgrFrGr\s r.r_r`sRUr0c[R"SUS[RS9n[U5S:am[R"SUS5Vs1sHGn[R"SU5(dUR 5(dM6UR S5iMI snO [5n[SUS9nU"US S 9nURXS 9sS S S 5 $s snf!,(df  g =f) u Immediately execute a SQL query, automatically registering frame globals. Notes ----- * This convenience method automatically registers all compatible objects in the local stack that are referenced in the query, mapping their variable name to a table name. Note that in addition to polars DataFrame, LazyFrame, and Series this method *also* registers pandas DataFrame, Series, and pyarrow Table and RecordBatch objects. * Instead of calling this classmethod you should consider using `pl.sql`, which will use this code internally. Parameters ---------- query A valid SQL query string. eager If True, returns execution results as `DataFrame` instead of `LazyFrame`. (Note that the query itself is always executed in lazy-mode). Examples -------- >>> import pandas as pd >>> df = pl.LazyFrame({"a": [1, 2, 3], "b": [4, 5, 6]}) >>> df_pandas = pd.DataFrame({"a": [2, 3, 4], "c": [7, 8, 9]}) Join a polars LazyFrame with a pandas DataFrame (note use of the preferred `pl.sql` method, which is equivalent to `SQLContext.execute_global`): >>> pl.sql("SELECT df.*, c FROM df JOIN df_pandas USING(a)").collect() shape: (2, 3) ┌─────┬─────┬─────┐ │ a ┆ b ┆ c │ │ --- ┆ --- ┆ --- │ │ i64 ┆ i64 ┆ i64 │ ╞═════╪═════╪═════╡ │ 2 ┆ 5 ┆ 7 │ │ 3 ┆ 6 ┆ 8 │ └─────┴─────┴─────┘ z\bFROM\b)maxsplitflagsz\bz ^("[^"]+")$"T)r<r9F)rJrC)r^rDN) resplitIlenmatch isidentifierstripsetr=execute)r]r^rDqnmpossible_namesrKctxs r.r_r`s` HH[%!244 @1vz((5!A$/ /B88NB//2??3D /   )NS  u =;;U;8> = > =s5C C=C C)c[US/5UlURR[UR 555 U$)zITrack currently registered tables on scope entry; supports nested scopes.rB)getattrrBappendrotablesrIs r. __enter__SQLContext.__enter__)s8#*41F#K    ''DKKM(:; r0cUR[UR55URR 5- S9 g)ze Unregister any tables created within the given scope on context exit. See Also -------- unregister )namesN) unregisterrorxrBpop)rIexc_typeexc_valexc_tbs r.__exit__SQLContext.__exit__/s7 t{{}%(@(@(D(D(FF  r0cZ[UR55nSUS[U5SS3$)Nz)rkrxid)rIn_tabless r.__repr__SQLContext.__repr__@s-t{{}%%hZwr$xl!DDr0cgrFrGrIr^rDs r.rpSQLContext.executeGr0cgrFrGrs r.rprLrr0cgrFrGrs r.rprQrr0cgrFrGrs r.rprVrr0cgrFrGrs r.rpr[rr0cgrFrGrs r.rpr`rr0cgrFrGrs r.rpres!$r0c[URRU55nU(dUR(aUR 5$U$)ug Parse the given SQL query and execute it against the registered frame data. Parameters ---------- query A valid string SQL query. eager Apply the query eagerly, returning `DataFrame` instead of `LazyFrame`. If unset, the value of the init-time "eager" parameter will be used. Note that the query itself is always executed in lazy-mode; this parameter only impacts the type of the returned frame. Examples -------- Declare frame data and register with a SQLContext: >>> df = pl.DataFrame( ... data=[ ... ("The Godfather", 1972, 6_000_000, 134_821_952, 9.2), ... ("The Dark Knight", 2008, 185_000_000, 533_316_061, 9.0), ... ("Schindler's List", 1993, 22_000_000, 96_067_179, 8.9), ... ("Pulp Fiction", 1994, 8_000_000, 107_930_000, 8.9), ... ("The Shawshank Redemption", 1994, 25_000_000, 28_341_469, 9.3), ... ], ... schema=["title", "release_year", "budget", "gross", "imdb_score"], ... orient="row", ... ) >>> ctx = pl.SQLContext(films=df) Execute a SQL query against the registered frame data: >>> ctx.execute( ... ''' ... SELECT title, release_year, imdb_score ... FROM films ... WHERE release_year > 1990 ... ORDER BY imdb_score DESC ... ''', ... eager=True, ... ) shape: (4, 3) ┌──────────────────────────┬──────────────┬────────────┐ │ title ┆ release_year ┆ imdb_score │ │ --- ┆ --- ┆ --- │ │ str ┆ i64 ┆ f64 │ ╞══════════════════════════╪══════════════╪════════════╡ │ The Shawshank Redemption ┆ 1994 ┆ 9.3 │ │ The Dark Knight ┆ 2008 ┆ 9.0 │ │ Schindler's List ┆ 1993 ┆ 8.9 │ │ Pulp Fiction ┆ 1994 ┆ 8.9 │ └──────────────────────────┴──────────────┴────────────┘ Execute a GROUP BY query: >>> ctx.execute( ... ''' ... SELECT ... MAX(release_year / 10) * 10 AS decade, ... SUM(gross) AS total_gross, ... COUNT(title) AS n_films, ... FROM films ... GROUP BY (release_year / 10) -- decade ... ORDER BY total_gross DESC ... ''', ... eager=True, ... ) shape: (3, 3) ┌────────┬─────────────┬─────────┐ │ decade ┆ total_gross ┆ n_films │ │ --- ┆ --- ┆ --- │ │ i64 ┆ i64 ┆ u32 │ ╞════════╪═════════════╪═════════╡ │ 2000 ┆ 533316061 ┆ 1 │ │ 1990 ┆ 232338648 ┆ 3 │ │ 1970 ┆ 134821952 ┆ 1 │ └────────┴─────────────┴─────────┘ )rr@rprAcollect)rIr^rDress r.rprjs9btzz))%01!&$*?*?s{{}IcIr0cUc [5O [U5nURRXR5 U$)u- Register a single frame as a table, using the given name. Parameters ---------- name Name of the table. frame eager/lazy frame to associate with this table name. See Also -------- register_globals register_many unregister Examples -------- >>> df = pl.DataFrame({"hello": ["world"]}) >>> ctx = pl.SQLContext() >>> ctx.register("frame_data", df).execute("SELECT * FROM frame_data").collect() shape: (1, 1) ┌───────┐ │ hello │ │ --- │ │ str │ ╞═══════╡ │ world │ └───────┘ )rr7r@register_ldf)rIrZr5s r.rSQLContext.registers2> %} 2CE2J D**- r0TrTc2[X!S9nURUS9$)u  Register all frames (lazy or eager) found in the current globals scope. Automatically maps variable names to table names. See Also -------- register register_many unregister Parameters ---------- n Register only the most recent "n" frames. all_compatible Control whether we *also* register pandas DataFrame, Series, and pyarrow Table and RecordBatch objects. If False, only Polars classes are registered with the SQL engine. Examples -------- >>> df1 = pl.DataFrame({"a": [1, 2, 3], "b": ["x", None, "z"]}) >>> df2 = pl.DataFrame({"a": [2, 3, 4], "c": ["t", "w", "v"]}) Register frames directly from variables found in the current globals scope: >>> ctx = pl.SQLContext(register_globals=True) >>> ctx.tables() ['df1', 'df2'] Query using the register variable/frame names >>> ctx.execute( ... "SELECT a, b, c FROM df1 LEFT JOIN df2 USING (a) ORDER BY a DESC" ... ).collect() shape: (3, 3) ┌─────┬──────┬──────┐ │ a ┆ b ┆ c │ │ --- ┆ --- ┆ --- │ │ i64 ┆ str ┆ str │ ╞═════╪══════╪══════╡ │ 3 ┆ z ┆ w │ │ 2 ┆ null ┆ t │ │ 1 ┆ x ┆ null │ └─────┴──────┴──────┘ )r<r8)rJ)r=rY)rInr<rJs r.rCSQLContext.register_globalss#d#.N!!!00r0c [U=(d 05nURU5 UR5Hup4URX45 M U$)a0 Register multiple eager/lazy frames as tables, using the associated names. Parameters ---------- frames A `{name:frame, ...}` mapping. **named_frames Named eager/lazy frames, provided as kwargs. See Also -------- register register_globals unregister Examples -------- >>> lf1 = pl.LazyFrame({"a": [1, 2, 3], "b": ["m", "n", "o"]}) >>> lf2 = pl.LazyFrame({"a": [2, 3, 4], "c": ["p", "q", "r"]}) >>> lf3 = pl.LazyFrame({"a": [3, 4, 5], "b": ["s", "t", "u"]}) >>> lf4 = pl.LazyFrame({"a": [4, 5, 6], "c": ["v", "w", "x"]}) Register multiple frames at once, either by passing in as a dict... >>> ctx = pl.SQLContext().register_many({"tbl1": lf1, "tbl2": lf2}) >>> ctx.tables() ['tbl1', 'tbl2'] ...or using keyword args: >>> ctx.register_many(tbl3=lf3, tbl4=lf4).tables() ['tbl1', 'tbl2', 'tbl3', 'tbl4'] )rVrXrWr)rIrJrKrZr5s r.rYSQLContext.register_manysBNfl# l#!<<>KD MM$ &* r0c~[U[5(aU/nUHnURRU5 M U$)aY Unregister one or more eager/lazy frames by name. Parameters ---------- names Names of the tables to unregister. Notes ----- You can also control table registration lifetime by using `SQLContext` as a context manager; this can often be more useful when such control is wanted: >>> df0 = pl.DataFrame({"colx": [0, 1, 2]}) >>> df1 = pl.DataFrame({"colx": [1, 2, 3]}) >>> df2 = pl.DataFrame({"colx": [2, 3, 4]}) Frames registered in-scope are automatically unregistered on scope-exit. Note that frames registered on construction will persist through subsequent scopes. >>> # register one frame at construction time, and the other two in-scope >>> with pl.SQLContext(tbl0=df0) as ctx: ... ctx.register_many(tbl1=df1, tbl2=df2).tables() ['tbl0', 'tbl1', 'tbl2'] After scope exit, none of the tables registered in-scope remain: >>> ctx.tables() ['tbl0'] See Also -------- register register_globals register_many Examples -------- >>> df0 = pl.DataFrame({"ints": [9, 8, 7, 6, 5]}) >>> lf1 = pl.LazyFrame({"text": ["a", "b", "c"]}) >>> lf2 = pl.LazyFrame({"misc": ["testing1234"]}) Register with a SQLContext object: >>> ctx = pl.SQLContext(test1=df0, test2=lf1, test3=lf2) >>> ctx.tables() ['test1', 'test2', 'test3'] Unregister one or more of the tables: >>> ctx.unregister(["test1", "test3"]).tables() ['test2'] >>> ctx.unregister("test2").tables() [] )r(strr@r~)rIr}rrs r.r~SQLContext.unregisterCs:p eS ! !GEB JJ ! !" % r0cH[URR55$)uI Return a list of the registered table names. Notes ----- The :meth:`tables` method will return the same values as the "SHOW TABLES" SQL statement, but as a list instead of a frame. Executing as SQL: >>> frame_data = pl.DataFrame({"hello": ["world"]}) >>> ctx = pl.SQLContext(hello_world=frame_data) >>> ctx.execute("SHOW TABLES", eager=True) shape: (1, 1) ┌─────────────┐ │ name │ │ --- │ │ str │ ╞═════════════╡ │ hello_world │ └─────────────┘ Calling the method: >>> ctx.tables() ['hello_world'] Examples -------- >>> df1 = pl.DataFrame({"hello": ["world"]}) >>> df2 = pl.DataFrame({"foo": ["bar", "baz"]}) >>> ctx = pl.SQLContext(hello_data=df1, foo_bar=df2) >>> ctx.tables() ['foo_bar', 'hello_data'] )sortedr@ get_tablesrys r.rxSQLContext.tablessHdjj++-..r0)r@rArB).)rISQLContext[LazyFrame]rJ/Mapping[str, CompatibleFrameType | None] | NonerC bool | intr<boolrDLiteral[False]rKCompatibleFrameType | NonereturnNone)rISQLContext[DataFrame]rJrrCrr<rrD Literal[True]rKrrr)rIrrJrrCrr<rrDrrKrrrrF) rJrrCrrDrrKrrr)r^rrDrrr)r^rrDrrr)r^rrDrrzDataFrame | LazyFrame)rzSQLContext[FrameType])rztype[BaseException] | NonerzBaseException | NonerzTracebackType | Nonerr)rr)rIrr^rrDrrr)rIrr^rrDrrr)rIrr^rrDrrr)rIrr^rrDrrr)rIrr^rrDrrr)rIrr^rrDrrr)r^rrDz bool | NonerzLazyFrame | DataFrame)rZrr5rrr$)r int | Noner<rrr$)rJrrKrrr$)r}zstr | Collection[str]rr$)rz list[str])__name__ __module__ __qualname____firstlineno____doc____annotations__rrLr classmethodr_rzrrrprrCrYr~rx__static_attributes__rGr0r.r&r&cs !!''CF(+" % #?%     3 CF(+" #?%     3 CF(+" #?%     3 !!2GYOCGA'(- A'?A'% A'  A' 3 A' A'PA'F49#1 RR UU*/<9<9#'<9 <9<9|  , & %    "EBE#,/;? #,/;I #,/;H BE#,/;? #,/;I #,/;H 25$$$/$ $$ 37RJRJ$/RJ RJh!H#31>B31317;31 31nCG+?+3+  +Z<|$/r0)r-rrr)r-rrr)r<rr8rr9z4str | Collection[str] | Callable[[str], bool] | Nonerzdict[str, Any])A __future__r contextlibrhtypingrrrrrpolars._typingr polars._utils.deprecationr polars._utils.pycapsuler polars._utils.unstabler polars._utils.variousr rpolars._utils.wraprpolars.convertrrpolars.dataframerpolars.dependenciesrrrr)rr*polars.lazyframer polars.seriesrsuppress ImportError polars._plrrsyscollections.abcrrtypesrrrr version_infor"typing_extensionsr$r+r,r%r__all__r/r7r=r&rGr0r.rs<" %A09H'2&E,-& %(&3#** 7"$/ 7"*%*  #    & .,!BF PPP @ P  PB /#B /Q&%s E E'