mia krya nyxta

gistfile1.ts

import * as sql from 'node-sql-parser'



const dummy_sql =
    [
        'SELECT cast(testcol as integer) FROM GAMIESAi',
        'SELECT cast(testcol as integer) FROM GAMIESAi',
        'SELECT cast(testcol as integer) FROM GAMIESAi',
        'SELECT cast(testcol as integer) FROM GAMIESAi',
        'SELECT cast(testcol as integer) FROM GAMIESAi',
    ]
const parser = new sql.Parser();
dummy_sql.map(t => {
    // console.log(parser.columnList(t))
    // console.log(parser.parse(t))
})


const arr = [1, 2, 4, 5, 6]

const chunkSize = 3
const chunkCount = Math.ceil(arr.length / chunkSize);
// console.log([...Array(chunkCount).keys()].map( i => arr.slice(i*chunkSize,(i+1)*chunkSize)))

const ast = parser.parse(dummy_sql[0]).ast as sql.AST;
type keys = typeof ast.type
type keyAst<T> = sql.AST & { type: T }
type loopkupSomething = { [k in keys]: (a: keyAst<k>) => void }
type cbType<T> = (a: keyAst<T>) => keyAst<T>

const lookup: { [k in keys]: cbType<k> } = {
    "select": (ast) => ast,
    "replace": (ast) => ast,
    "update": (ast) => ast,
    "delete": (ast) => ast,
    "alter": (ast) => ast,
    "create": (ast) => ast,
    "insert": (ast) => ast,
    "use": (ast) => ast,
}
const cb = lookup["insert"]

type idx =1
type k2 = {"a","b"}
type arr = [a:number,b:string,c:boolean,...d:any[]]
// type arr = number
type k = arr[keyof arr]
type y = keyof k
const v = {a:1,b:1}
type B = "B"
type TouMhden<T> = T extends [] ? never:T extends [infer A,...infer D] ? A: T 
type TouLast<T> = T extends [] ? never:T extends [...infer A,infer D] ? D: T 
type Toggle<T,A,B> = T extends A? B: A
type BuildArray<N extends Number,V extends any[]=[] > = V extends {length:N} ? V : BuildArray<N,[Toggle<V[0],string,number>,...V]>
type BuildArrayAny<N extends Number,V extends any[]=[],V2 extends any[] = [any] > = V extends {length:N} ? V : V2 extends {length:N}? V2: BuildArrayAny<N,[any,any,...V],[any,any,...V2]>
type TouN<T extends unknown[],N extends Number> = T extends [...BuildArrayAny<N>,infer B,...infer C] ? B:never

type add<A extends Number, B extends Number> = [...BuildArray<A>,...BuildArray<B>] extends {length: infer D}? D: 0
type getLength<T> = T extends {length: infer D}? D:never
// type ToNumber<T,V extends any[]=[]> = T extends Number? T : T extends `${getLength<V>}`? getLength<V>: ToNumber<T,[any,...V]>
type ToNumber<T extends string> = T extends `${infer Result extends number}`? Result: never
type abs<T extends number> = ToNumber<`${T}` extends `-${infer B}`? B:`${T}`>
type IsPositive<T extends number> = `${T}` extends `-${infer B}`?false:true
type TheBig<BIG extends number,SMALL extends number> = IsPositive<BIG> | IsPositive<SMALL> extends true ? BIG: IsPositive<BIG> extends true? BIG : SMALL
type max<A extends number, B extends number> = BuildArrayAny<abs<A>> extends [...BuildArrayAny<abs<B>>,...infer C]? TheBig<A,B>:TheBig<B,A>
type max2 = max<5,7>
type bigboi = getLength<BuildArrayAny<2500>>
type checkup = IsPositive<2> | IsPositive<3>
// type kati2 = add<2,-3>
// type IntToString<T extends number> = `${T}`

// type negatives ={
//     [-1] : 'test'
// };
// type test = keyof negatives;


// type sub<A extends Number,B extends Number> = BuildArrayAny<A> extends [...BuildArrayAny<B>,...infer C]? getLength<C>:never

// type kanemestring = `-${abs<-2>}`
// type kati3 = ToNumber<abs<-2>>

type kati = Toggle<any,string,number>




type w = TouMhden<[number]>
type z = TouLast<[number,string]>

const za:w = [1,"df",true]

// switch(ast.type){
//     case "select":
//         console.log(ast.columns)
//         break
/