q-Ph]UddlmZddlZddlZddlmZmZmZmZm Z ddl m Z ddl m Z ddlmZddlmZddlmZmZdd lmZdd lmZmZdd lmZdd lmZmZdd lmZ ddlm!Z"ddl#m$Z$ddl%m&Z&ej'e(5ddl)m*Z*dddn #1swxYwYerzddl+Z+ddl,m-Z-m.Z.ddl/m0Z0ddlm1Z1m2Z2m3Z3e+j4dkrddlm5Z5nddl6m5Z5e+j4dkrddlm7Z7nddl6m7Z7eee$e&e je j&e1e"j8e"j9fZ:de;d<dgZddd#d.d*Z?Gd+dee Z@dS)/) 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 SQLContextobjrreturnboolct|p~t|tpit|o%t|tjtjfp4t|o%t|tj tj fS)z2Check if the object can be converted to DataFrame.) r isinstancerrpdrrrpaTable RecordBatch)r's R/var/www/html/test/jupyter/venv/lib/python3.11/site-packages/polars/sql/context.py_compatible_framer1;s{ S U c9 % % U c " " Qz# bi7P'Q'Q U s # # S 32>8R(S(S rct|ttfr|St|tr&|St |rrt|tjtjfrLtt|x}tr|}|St|s5t|rGt|tj tj fr!t|Sdt|}t!|)z'Return LazyFrame from compatible input.zunrecognised frame type: )r+rrlazyrto_framerr,rr rr-r.r/rr ValueError)r'framemsgs r0_ensure_lazyframer9Es0# 9-..xxzz C ||~~""$$$ 3   JsR\294M$N$N  {3///e 8 8 %NN$$Ezz|| c  3$.sRXr~4N$O$O###%%%D*=c*B*BDDoor2) n_objectsnamedall_compatibler: int | Noner;4str | Collection[str] | Callable[[str], bool] | Nonedict[str, Any]c`|rtntttf}t |||S)z5Return compatible frame objects from the local stack.)of_typer:r;)r1rrrr )r<r:r;rAs r0_get_frame_localsrBXs0$2U 9f7UG W  O O OOr2ceZdZUdZded<ded<ded<e dRddd d dSdZe dRddddTdZe dRddddUdZeddd ! dVd d d#dWd$Zeed d%dXd)Z eedYd+Z eedZd-Z ed d%dZd.Z d[d0Z d\d7Z d]d8Z edd%d^d9Z ed_d:Z ed`d;Z edd%dad<Z edbd=Z edcd>Z edd%dddAZ d"d%dddBZ dedFZ dVdGdHdfdKZ dVdgdLZdhdOZdidQZd"S)jr&a  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<eagerselfSQLContext[LazyFrame]frames/Mapping[str, CompatibleFrameType | None] | NonerG bool | intr<r)rHLiteral[False] named_framesCompatibleFrameType | Noner(Nonec dSNrIrKrGr<rHrOs r0__init__zSQLContext.__init__w sr2)rGr<SQLContext[DataFrame] Literal[True]c dSrSrTrUs r0rVzSQLContext.__init__rWr2c dSrSrTrUs r0rVzSQLContext.__init__rWr2eager_executionz0.20.31)versionN)rGrHc Rtdtj|_||_t |pi}|r5t dD]\}}||vr ||vr|||<|s|r,||| |dSdS)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 rnewrDrEdictrBitemsupdate register_many)rIrKrGrHrOnamer's r0rVzSQLContext.__init__sd  g   "%'' %fl##  -.$egg - - cv%%$l*B*B),L&  '\ ' MM, ' ' '   v & & & & & ' 'r2)rHquerystrrcdSrSrTclsrfrHs r0execute_globalzSQLContext.execute_globals Cr2rcdSrSrTris r0rkzSQLContext.execute_globalsORsr2DataFrame | LazyFramecdSrSrTris r0rkzSQLContext.execute_globalsRURUr2cptjd|dtj}t|dkr%dtjd|dDn t }t d|}||d 5}||| cd d d S#1swxYwYd S) 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)maxsplitflagsch|]@}tjd|s|+|dAS)z ^("[^"]+")$")rematch isidentifierstrip).0nms r0 z,SQLContext.execute_global..sX   8NB// 46??3D3D     r2z\bT)r<r;F)rKrG)rfrHN)rusplitIlensetrBexecute)rjrfrHqpossible_namesrOctxs r0rkzSQLContext.execute_globals ` H[%!24 @ @ @1vvzz   (5!A$//      )NSSS S u = = = 9;;U%;88 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9sB++B/2B/SQLContext[FrameType]ct|dg|_|jt||S)zITrack currently registered tables on scope entry; supports nested scopes.rF)getattrrFappendrtablesrIs r0 __enter__zSQLContext.__enter__)sC#*41F#K#K   ''DKKMM(:(:;;; r2exc_typetype[BaseException] | Noneexc_valBaseException | Noneexc_tbTracebackType | Nonec|t||jz dS)z Unregister any tables created within the given scope on context exit. See Also -------- unregister )namesN) unregisterrrrFpop)rIrrrs r0__exit__zSQLContext.__exit__/sP t{{}}%%(@(D(D(F(FF      r2crt|}d|dt|ddS)Nz)r~rid)rIn_tabless r0__repr__zSQLContext.__repr__@s9t{{}}%%DhDDr$xxDDDDDr2cdSrSrTrIrfrHs r0rzSQLContext.executeG Cr2cdSrSrTrs r0rzSQLContext.executeLrr2cdSrSrTrs r0rzSQLContext.executeQrr2cdSrSrTrs r0rzSQLContext.executeVrr2cdSrSrTrs r0rzSQLContext.execute[rr2cdSrSrTrs r0rzSQLContext.execute`rr2 bool | NoneLazyFrame | DataFramecdSrSrTrs r0rzSQLContext.executees !$r2ct|j|}|s|jr|n|S)u 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 │ └────────┴─────────────┴─────────┘ )rrDrrEcollect)rIrfrHress r0rzSQLContext.executejsAbtz))%0011!&I$*?Is{{}}}cIr2rer7r$c|tnt|}|j||j|S)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 │ └───────┘ )rr9rDregister_ldf)rIrer7s r0rzSQLContext.registers=> %} 2CE2J2J D%*--- r2Tr_nr=cPt||}||S)u9 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<r:)rK)rBrd)rIrr<rKs r0rGzSQLContext.register_globalss.d#.ANNN!!!000r2c t|pi}|||D]\}}||||S)a 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'] )rarcrbr)rIrKrOrer7s r0rdzSQLContext.register_manys_Nfl## l###!<<>> ' 'KD% MM$ & & & & r2rstr | Collection[str]ctt|tr|g}|D]}|j||S)a 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+rgrDr)rIrrzs r0rzSQLContext.unregisterCsKp eS ! ! GE & &B J ! !" % % % % r2 list[str]cNt|jS)u) 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'] )sortedrD get_tablesrs r0rzSQLContext.tabless!Hdj++--...r2).)rIrJrKrLrGrMr<r)rHrNrOrPr(rQ)rIrXrKrLrGrMr<r)rHrYrOrPr(rQ)rIrXrKrLrGrMr<r)rHr)rOrPr(rQrS) rKrLrGrMrHr)rOrPr(rQ)rfrgrHrNr(r)rfrgrHrYr(r)rfrgrHr)r(rm)r(r)rrrrrrr(rQ)r(rg)rIrXrfrgrHrQr(r)rIrXrfrgrHrNr(r)rIrXrfrgrHrYr(r)rIrJrfrgrHrQr(r)rIrJrfrgrHrNr(r)rIrJrfrgrHrYr(r)rfrgrHrr(r)rergr7rPr(r$)rr=r<r)r(r$)rKrLrOrPr(r$)rrr(r$)r(r)__name__ __module__ __qualname____doc____annotations__rrVr classmethodrkrrrrrrGrdrrrTr2r0r&r&cs!!!!''''CF(+" % XCF(+" XCF(+" X! !2GYOOOCGA'(- A'A'A'A'A'POA'F49[XRRR[XR UUU[XU*/<9<9<9<9<9[<9|     "EEEEBEXXXBEXXX25$$$$$X$ 37RJRJRJRJRJRJh!!!!H#31>B313131313131nCG+++++Z<<<<|$/$/$/$/$/$/r2)r'rr(r))r'rr(r)r<r)r:r=r;r>r(r?)A __future__r contextlibrutypingrrrrrpolars._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.polarsrsyscollections.abcrrtypesrrrr version_infor"typing_extensionsr$r.r/r%r__all__r1r9rBr&rTr2r0rs""""""" %$$$$$AAAAAA000000999999HHHHHHHH''''''22222222&&&&&&EEEEEEEE,,,,,,------&&&&&& Z%%++******+++++++++++++++JJJ33333333######********** 7""$$$$$$$////// 7""******%*  #    & .,!BF PPPPPPB /B /B /B /B /#B /B /B /B /B /sBBB